//------------------------------------------------------------------------------ // FindAppTester.cpp // //------------------------------------------------------------------------------ // Standard Includes ----------------------------------------------------------- #include #include #include // System Includes ------------------------------------------------------------- #include #include #include #include #include #include #include #include #include #include #include // Project Includes ------------------------------------------------------------ #include #include #include // Local Includes -------------------------------------------------------------- #include "AppRunner.h" #include "FindAppTester.h" // Local Defines --------------------------------------------------------------- // Globals --------------------------------------------------------------------- //------------------------------------------------------------------------------ static const char *uninstalledType = "application/x-vnd.obos-roster-findapp-uninstalled"; static const char *appType1 = "application/x-vnd.obos-roster-findapp-app1"; static const char *appType2 = "application/x-vnd.obos-roster-findapp-app2"; static const char *fileType1 = "application/x-vnd.obos-roster-findapp-file1"; static const char *fileType2 = "application/x-vnd.obos-roster-findapp-file2"; static const char *textTestType = "text/x-vnd.obos-roster-findapp"; static const char *testDir = "/tmp/testdir"; static const char *appFile1 = "/tmp/testdir/app1"; static const char *appFile2 = "/tmp/testdir/app2"; static const char *testFile1 = "/tmp/testdir/testFile1"; static const char *testLink1 = "/tmp/testdir/testLink1"; static const char *trashAppName = "roster-findapp-app"; // get_trash_app_file static const char* get_trash_app_file() { static char trashAppFile[B_PATH_NAME_LENGTH]; static bool initialized = false; if (!initialized) { BPath path; CHK(find_directory(B_TRASH_DIRECTORY, &path) == B_OK); CHK(path.Append(trashAppName) == B_OK); strcpy(trashAppFile, path.Path()); initialized = true; } return trashAppFile; } // install_type static void install_type(const char *type, const char *preferredApp = NULL, const char *snifferRule = NULL) { BMimeType mimeType(type); if (!mimeType.IsInstalled()) CHK(mimeType.Install() == B_OK); if (preferredApp) CHK(mimeType.SetPreferredApp(preferredApp) == B_OK); if (snifferRule) CHK(mimeType.SetSnifferRule(snifferRule) == B_OK); } // ref_for_path static entry_ref ref_for_path(const char *filename, bool traverse = true) { entry_ref ref; BEntry entry; CHK(entry.SetTo(filename, traverse) == B_OK); CHK(entry.GetRef(&ref) == B_OK); return ref; } // create_app static void create_app(const char *filename, const char *signature = NULL, bool install = false, bool makeExecutable = true) { system((string("touch ") + filename).c_str()); if (makeExecutable) system((string("chmod a+x ") + filename).c_str()); if (signature) { BFile file; CHK(file.SetTo(filename, B_READ_WRITE) == B_OK); BAppFileInfo appFileInfo; CHK(appFileInfo.SetTo(&file) == B_OK); CHK(appFileInfo.SetSignature(signature) == B_OK); if (install) CHK(BMimeType(signature).Install() == B_OK); } } // create_file static entry_ref create_file(const char *filename, const char *type, const char *preferredApp = NULL, const char *appHintPath = NULL, const char *contents = NULL) { if (contents) system((string("echo -n \"") + contents + "\" > " + filename).c_str()); else system((string("touch ") + filename).c_str()); if (type || preferredApp || appHintPath) { BFile file; CHK(file.SetTo(filename, B_READ_WRITE) == B_OK); BNodeInfo nodeInfo; CHK(nodeInfo.SetTo(&file) == B_OK); if (type) CHK(nodeInfo.SetType(type) == B_OK); if (preferredApp) CHK(nodeInfo.SetPreferredApp(preferredApp) == B_OK); if (appHintPath) { entry_ref appHint(ref_for_path(appHintPath)); CHK(nodeInfo.SetAppHint(&appHint) == B_OK); } } return ref_for_path(filename); } // check_app_type static void check_app_type(const char *signature, const char *filename) { BMimeType type(signature); CHK(type.IsInstalled() == true); if (filename) { entry_ref appHint; CHK(type.GetAppHint(&appHint) == B_OK); CHK(ref_for_path(filename) == appHint); } } // set_file_time static void set_file_time(const char *filename, time_t time) { utimbuf buffer; buffer.actime = time; buffer.modtime = time; CHK(utime(filename, &buffer) == 0); } // set_version static void set_version(const char *filename, uint32 version) { version_info versionInfo = { 1, 1, 1, 1, version, "short1", "long1" }; BFile file; CHK(file.SetTo(filename, B_READ_WRITE) == B_OK); BAppFileInfo appFileInfo; CHK(appFileInfo.SetTo(&file) == B_OK); CHK(appFileInfo.SetVersionInfo(&versionInfo, B_APP_VERSION_KIND) == B_OK); } // set_type_app_hint static void set_type_app_hint(const char *signature, const char *filename) { BMimeType type(signature); if (!type.IsInstalled()); CHK(type.Install() == B_OK); entry_ref fileRef(ref_for_path(filename)); CHK(type.SetAppHint(&fileRef) == B_OK); } // setUp void FindAppTester::setUp() { fApplication = new BApplication("application/x-vnd.obos-roster-findapp"); system((string("mkdir ") + testDir).c_str()); } // tearDown void FindAppTester::tearDown() { BMimeType(uninstalledType).Delete(); BMimeType(appType1).Delete(); BMimeType(appType2).Delete(); BMimeType(fileType1).Delete(); BMimeType(fileType2).Delete(); BMimeType(textTestType).Delete(); delete fApplication; system((string("rm -rf ") + testDir).c_str()); system((string("rm -f ") + get_trash_app_file()).c_str()); } // FindAppCaller class FindAppCaller { public: virtual status_t operator()(const char *type, entry_ref *ref) = 0; }; /* @case 1 uninstalled type mimeType @results Should return B_LAUNCH_FAILED_APP_NOT_FOUND. */ static void CommonFindAppTest1(FindAppCaller &caller) { BRoster roster; entry_ref ref; CHK(caller(uninstalledType, &ref) == B_LAUNCH_FAILED_APP_NOT_FOUND); } /* @case 2 installed type mimeType, no preferred app @results Should return B_LAUNCH_FAILED_NO_PREFERRED_APP. */ static void CommonFindAppTest2(FindAppCaller &caller) { BRoster roster; install_type(fileType1); entry_ref ref; CHK(caller(fileType1, &ref) == B_LAUNCH_FAILED_NO_PREFERRED_APP); } /* @case 3 installed type mimeType, preferred app, app type not installed, app has no signature @results Should return B_LAUNCH_FAILED_APP_NOT_FOUND. */ static void CommonFindAppTest3(FindAppCaller &caller) { BRoster roster; install_type(fileType1, appType1); entry_ref ref; CHK(caller(fileType1, &ref) == B_LAUNCH_FAILED_APP_NOT_FOUND); } /* @case 4 installed type mimeType, preferred app, app type not installed, app has signature @results Should return B_OK and set the ref to refer to the application's executable. Should install the app type and set the app hint on it. */ static void CommonFindAppTest4(FindAppCaller &caller) { BRoster roster; create_app(appFile1, appType1); install_type(fileType1, appType1); entry_ref ref; CHK(caller(fileType1, &ref) == B_OK); CHK(ref_for_path(appFile1) == ref); check_app_type(appType1, appFile1); } /* @case 5 installed type mimeType, preferred app, app type installed, app has signature @results Should return B_OK and set the ref to refer to the application'sexecutable. Should set the app hint on the app type. */ static void CommonFindAppTest5(FindAppCaller &caller) { BRoster roster; create_app(appFile1, appType1, true); install_type(fileType1, appType1); entry_ref ref; CHK(caller(fileType1, &ref) == B_OK); CHK(ref_for_path(appFile1) == ref); check_app_type(appType1, appFile1); } /* @case 6 installed type mimeType, preferred app, app type installed, app has signature, app has no execute permission @results Should return B_OK and set the ref to refer to the application's executable. Should set the app hint on the app type. */ static void CommonFindAppTest6(FindAppCaller &caller) { BRoster roster; create_app(appFile1, appType1, true, false); install_type(fileType1, appType1); entry_ref ref; CHK(caller(fileType1, &ref) == B_OK); CHK(ref_for_path(appFile1) == ref); check_app_type(appType1, appFile1); } /* @case 7 installed type mimeType, preferred app, app type installed, two apps have the signature @results Should return B_OK and set the ref to refer to the application executable with the most recent modification time. Should set the app hint on the app type. */ static void CommonFindAppTest7(FindAppCaller &caller) { BRoster roster; create_app(appFile1, appType1); create_app(appFile2, appType1, true); set_file_time(appFile2, time(NULL) + 1); install_type(fileType1, appType1); entry_ref ref; CHK(caller(fileType1, &ref) == B_OK); CHK(ref_for_path(appFile2) == ref); check_app_type(appType1, appFile2); } /* @case 8 installed type mimeType, preferred app, app type installed, two apps have the signature, one has a version info, the other one is newer @results Should return B_OK and set the ref to refer to the application executable with version info. Should set the app hint on the app type. */ static void CommonFindAppTest8(FindAppCaller &caller) { BRoster roster; create_app(appFile1, appType1); set_version(appFile1, 1); create_app(appFile2, appType1, true); set_file_time(appFile2, time(NULL) + 1); install_type(fileType1, appType1); entry_ref ref; CHK(caller(fileType1, &ref) == B_OK); CHK(ref_for_path(appFile1) == ref); check_app_type(appType1, appFile1); } /* @case 9 installed type mimeType, preferred app, app type installed, two apps have the signature, both apps have a version info @results Should return B_OK and set the ref to refer to the application executable with the greater version. Should set the app hint on the app type. */ static void CommonFindAppTest9(FindAppCaller &caller) { BRoster roster; create_app(appFile1, appType1); set_version(appFile1, 2); create_app(appFile2, appType1, true); set_version(appFile1, 1); set_file_time(appFile2, time(NULL) + 1); install_type(fileType1, appType1); entry_ref ref; CHK(caller(fileType1, &ref) == B_OK); CHK(ref_for_path(appFile1) == ref); check_app_type(appType1, appFile1); } /* @case 10 installed type mimeType, preferred app, app type installed, preferred app type has an app hint that points to an app with a different signature @results Should return B_OK and set the ref to refer to the application's executable. Should remove the incorrect app hint on the app type. (Haiku: Should set the correct app hint. Don't even return the wrong app?) */ static void CommonFindAppTest10(FindAppCaller &caller) { BRoster roster; create_app(appFile1, appType2); set_type_app_hint(appType1, appFile1); entry_ref appHint; CHK(BMimeType(appType1).GetAppHint(&appHint) == B_OK); install_type(fileType1, appType1); entry_ref ref; CHK(caller(fileType1, &ref) == B_OK); CHK(ref_for_path(appFile1) == ref); CHK(BMimeType(appType1).GetAppHint(&appHint) == B_ENTRY_NOT_FOUND); // Haiku: We set the app hint for app type 2. There's no reason not to do it. #ifdef TEST_R5 CHK(BMimeType(appType2).IsInstalled() == false); #else check_app_type(appType2, appFile1); #endif } /* @case 11 installed type mimeType, preferred app, app type installed, preferred app type has an app hint pointing to void, a differently named app with this signature exists @results Should return B_OK and set the ref to refer to the application's executable. Should update the app hint on the app type. */ static void CommonFindAppTest11(FindAppCaller &caller) { BRoster roster; create_app(appFile1, appType1); set_type_app_hint(appType1, appFile2); install_type(fileType1, appType1); entry_ref ref; CHK(caller(fileType1, &ref) == B_OK); CHK(ref_for_path(appFile1) == ref); check_app_type(appType1, appFile1); } /* @case 12 mimeType is app signature, not installed @results Should return B_OK and set the ref to refer to the application executable. Should set the app hint on the app type. */ static void CommonFindAppTest12(FindAppCaller &caller) { BRoster roster; create_app(appFile1, appType1); entry_ref ref; CHK(caller(appType1, &ref) == B_OK); CHK(ref_for_path(appFile1) == ref); check_app_type(appType1, appFile1); } /* @case 13 mimeType is installed, but has no preferred application, super type has preferred application @results Should return B_OK and set the ref to refer to the application executable associated with the preferred app of the supertype. Should set the app hint on the app type. */ static void CommonFindAppTest13(FindAppCaller &caller) { BRoster roster; // make sure, the original preferred app for the "text" supertype is // re-installed struct TextTypeSaver { TextTypeSaver() { BMimeType textType("text"); hasPreferredApp = (textType.GetPreferredApp(preferredApp) == B_OK); } ~TextTypeSaver() { BMimeType textType("text"); textType.SetPreferredApp(hasPreferredApp ? preferredApp : NULL); } bool hasPreferredApp; char preferredApp[B_MIME_TYPE_LENGTH]; } _saver; create_app(appFile1, appType1); CHK(BMimeType("text").SetPreferredApp(appType1) == B_OK); install_type(textTestType); entry_ref ref; CHK(caller(textTestType, &ref) == B_OK); CHK(ref_for_path(appFile1) == ref); check_app_type(appType1, appFile1); } /* @case 14 installed type mimeType, preferred app, app type not installed, app has signature, app is trash @results Should return B_LAUNCH_FAILED_APP_IN_TRASH. */ static void CommonFindAppTest14(FindAppCaller &caller) { BRoster roster; create_app(get_trash_app_file(), appType1); install_type(fileType1, appType1); entry_ref ref; CHK(caller(fileType1, &ref) == B_LAUNCH_FAILED_APP_IN_TRASH); } /* @case 15 installed type mimeType, preferred app, app type installed, preferred app type has an app hint pointing to void, no app with this signature exists @results Should return B_LAUNCH_FAILED_APP_NOT_FOUND and unset the app type's app hint. */ static void CommonFindAppTest15(FindAppCaller &caller) { BRoster roster; set_type_app_hint(appType1, appFile1); install_type(fileType1, appType1); entry_ref ref; CHK(caller(fileType1, &ref) == B_LAUNCH_FAILED_APP_NOT_FOUND); entry_ref appHint; CHK(BMimeType(appType1).GetAppHint(&appHint) == B_ENTRY_NOT_FOUND); } /* @case 16 installed type mimeType, preferred app, app type installed, preferred app type has an app hint pointing to a cyclic link, no app with this signature exists @results R5: Should return B_OK and set the ref to refer to the link. Haiku: Should return B_LAUNCH_FAILED_APP_NOT_FOUND and unset the app type's app hint. */ static void CommonFindAppTest16(FindAppCaller &caller) { BRoster roster; set_type_app_hint(appType1, appFile1); install_type(fileType1, appType1); system((string("ln -s ") + appFile1 + " " + appFile1).c_str()); entry_ref ref; entry_ref appHint; #ifdef TEST_R5 CHK(caller(fileType1, &ref) == B_OK); CHK(ref_for_path(appFile1, false) == ref); CHK(BMimeType(appType1).GetAppHint(&appHint) == B_OK); CHK(appHint == ref); #else CHK(caller(fileType1, &ref) == B_LAUNCH_FAILED_APP_NOT_FOUND); CHK(BMimeType(appType1).GetAppHint(&appHint) == B_ENTRY_NOT_FOUND); #endif } typedef void commonTestFunction(FindAppCaller &caller); static commonTestFunction *commonTestFunctions[] = { CommonFindAppTest1, CommonFindAppTest2, CommonFindAppTest3, CommonFindAppTest4, CommonFindAppTest5, CommonFindAppTest6, CommonFindAppTest7, CommonFindAppTest8, CommonFindAppTest9, CommonFindAppTest10, CommonFindAppTest11, CommonFindAppTest12, CommonFindAppTest13, CommonFindAppTest14, CommonFindAppTest15, CommonFindAppTest16 }; static int32 commonTestFunctionCount = sizeof(commonTestFunctions) / sizeof(commonTestFunction*); /* status_t FindApp(const char *mimeType, entry_ref *app) const @case 1 mimeType or app are NULL @results Should return B_BAD_VALUE. */ void FindAppTester::FindAppTestA1() { BRoster roster; CHK(roster.FindApp((const char*)NULL, NULL) == B_BAD_VALUE); // R5: crashes when passing a non-NULL type, but a NULL ref. #ifndef TEST_R5 CHK(roster.FindApp("image/gif", NULL) == B_BAD_VALUE); #endif entry_ref ref; CHK(roster.FindApp((const char*)NULL, &ref) == B_BAD_VALUE); } /* status_t FindApp(const char *mimeType, entry_ref *app) const @case 2 mimeType is invalid @results Should return B_BAD_VALUE. */ void FindAppTester::FindAppTestA2() { BRoster roster; entry_ref ref; CHK(roster.FindApp("invalid/mine/type", &ref) == B_BAD_VALUE); } // FindAppTypeCaller class FindAppTypeCaller : public FindAppCaller { public: virtual status_t operator()(const char *type, entry_ref *ref) { BRoster roster; return roster.FindApp(type, ref); } }; /* status_t FindApp(const char *mimeType, entry_ref *app) const @case 3 FindApp(const char*, entry_ref*) cases 3-16 (== common cases 1-14) */ void FindAppTester::FindAppTestA3() { FindAppTypeCaller caller; for (int32 i = 0; i < commonTestFunctionCount; i++) { NextSubTest(); (*commonTestFunctions[i])(caller); tearDown(); setUp(); } } /* status_t FindApp(entry_ref *ref, entry_ref *app) const @case 1 ref or app are NULL @results Should return B_BAD_VALUE. */ void FindAppTester::FindAppTestB1() { BRoster roster; CHK(roster.FindApp((entry_ref*)NULL, NULL) == B_BAD_VALUE); // R5: Crashes when passing a NULL (app) ref. #ifndef TEST_R5 create_app(appFile1, appType1); entry_ref fileRef(create_file(testFile1, fileType1, appType1)); CHK(roster.FindApp(&fileRef, NULL) == B_BAD_VALUE); #endif entry_ref ref; CHK(roster.FindApp((entry_ref*)NULL, &ref) == B_BAD_VALUE); } /* status_t FindApp(entry_ref *ref, entry_ref *app) const @case 2 ref doesn't refer to an existing entry => @results Should return B_ENTRY_NOT_FOUND. */ void FindAppTester::FindAppTestB2() { BRoster roster; entry_ref fileRef(ref_for_path(testFile1)); entry_ref ref; CHK(roster.FindApp(&fileRef, &ref) == B_ENTRY_NOT_FOUND); } /* status_t FindApp(entry_ref *ref, entry_ref *app) const @case 3 ref is valid, file has type and preferred app, preferred app is in trash @results Should return B_LAUNCH_FAILED_APP_IN_TRASH. */ void FindAppTester::FindAppTestB3() { BRoster roster; create_app(get_trash_app_file(), appType1); entry_ref fileRef(create_file(testFile1, fileType1, appType1)); entry_ref ref; CHK(roster.FindApp(&fileRef, &ref) == B_LAUNCH_FAILED_APP_IN_TRASH); } /* status_t FindApp(entry_ref *ref, entry_ref *app) const @case 4 ref is valid, file has type and preferred app, app type is not installed, app exists and has signature @results Should return B_OK and set the ref to refer to the file's (not the file type's) preferred application's executable. Should install the app type and set the app hint on it. */ void FindAppTester::FindAppTestB4() { BRoster roster; create_app(appFile1, appType1); create_app(appFile2, appType2); install_type(fileType1, appType1); entry_ref fileRef(create_file(testFile1, fileType1, appType2)); entry_ref ref; CHK(roster.FindApp(&fileRef, &ref) == B_OK); CHK(ref_for_path(appFile2) == ref); check_app_type(appType2, appFile2); } /* status_t FindApp(entry_ref *ref, entry_ref *app) const @case 5 ref is valid, file has no type, but preferred app, app type is not installed, app exists and has signature @results Should return B_OK and set the ref to refer to the application's executable. Should install the app type and set the app hint on it. */ void FindAppTester::FindAppTestB5() { BRoster roster; create_app(appFile1, appType1); entry_ref fileRef(create_file(testFile1, NULL, appType1)); entry_ref ref; CHK(roster.FindApp(&fileRef, &ref) == B_OK); CHK(ref_for_path(appFile1) == ref); check_app_type(appType1, appFile1); } /* status_t FindApp(entry_ref *ref, entry_ref *app) const @case 6 ref is valid, file has type and app hint, the type's preferred app type is not installed, app exists and has signature @results Should return B_OK and set the ref to refer to the file type's preferred application's executable. Should install the app type and set the app hint on it. */ void FindAppTester::FindAppTestB6() { BRoster roster; create_app(appFile1, appType1); create_app(appFile2, appType2); install_type(fileType1, appType1); entry_ref fileRef(create_file(testFile1, fileType1, NULL, appFile2)); entry_ref ref; CHK(roster.FindApp(&fileRef, &ref) == B_OK); CHK(ref_for_path(appFile1) == ref); check_app_type(appType1, appFile1); } /* status_t FindApp(entry_ref *ref, entry_ref *app) const @case 7 ref is valid, file has type, the type's preferred app type is not installed, app exists and has signature, file is executable @results Should return B_OK and set the ref to refer to the file. Should not set the app hint on the app or file type (Why?). */ void FindAppTester::FindAppTestB7() { BRoster roster; create_app(appFile1, appType1); install_type(fileType1, appType1); entry_ref fileRef(create_file(testFile1, fileType1)); system((string("chmod a+x ") + testFile1).c_str()); entry_ref ref; CHK(roster.FindApp(&fileRef, &ref) == B_OK); CHK(ref_for_path(testFile1) == ref); CHK(BMimeType(appType1).IsInstalled() == false); CHK(BMimeType(fileType1).GetAppHint(&ref) == B_ENTRY_NOT_FOUND); } /* status_t FindApp(entry_ref *ref, entry_ref *app) const @case 8 ref is valid and refers to a link to a file, file has type, the type's preferred app type is not installed, app exists and has signature @results Should return B_OK and set the ref to refer to the file type's preferred application's executable. Should install the app type and set the app hint on it. */ void FindAppTester::FindAppTestB8() { BRoster roster; create_app(appFile1, appType1); install_type(fileType1, appType1); create_file(testFile1, fileType1); system((string("ln -s ") + testFile1 + " " + testLink1).c_str()); entry_ref linkRef(ref_for_path(testLink1, false)); entry_ref ref; CHK(roster.FindApp(&linkRef, &ref) == B_OK); CHK(ref_for_path(appFile1) == ref); check_app_type(appType1, appFile1); } // FileWithTypeCaller class FileWithTypeCaller : public FindAppCaller { public: virtual status_t operator()(const char *type, entry_ref *ref) { BRoster roster; entry_ref fileRef(create_file(testFile1, type)); return roster.FindApp(&fileRef, ref); } }; /* status_t FindApp(entry_ref *ref, entry_ref *app) const @case 9 ref is valid, file has no type, sniffing results in a type, type is set on file, FindApp(const char*, entry_ref*) cases 4-16 (== common cases 2-14) */ void FindAppTester::FindAppTestB9() { FileWithTypeCaller caller; for (int32 i = 0; i < commonTestFunctionCount; i++) { NextSubTest(); (*commonTestFunctions[i])(caller); tearDown(); setUp(); } } // SniffFileTypeCaller class SniffFileTypeCaller : public FindAppCaller { public: virtual status_t operator()(const char *type, entry_ref *ref) { BRoster roster; entry_ref fileRef(create_file(testFile1, type, NULL, NULL, "UnIQe pAtTeRn")); install_type(fileType1, NULL, "1.0 [0] ('UnIQe pAtTeRn')"); return roster.FindApp(&fileRef, ref); } }; /* status_t FindApp(entry_ref *ref, entry_ref *app) const @case 10 ref is valid, file has no type, sniffing results in a type, type is set on file, FindApp(const char*, entry_ref*) cases 3-16 (== common cases 1-14) */ void FindAppTester::FindAppTestB10() { SniffFileTypeCaller caller; for (int32 i = 1; i < commonTestFunctionCount; i++) { NextSubTest(); (*commonTestFunctions[i])(caller); tearDown(); setUp(); } } /* status_t FindApp(entry_ref *ref, entry_ref *app) const @case 11 ref is valid and refers to a cyclic link @results Should return B_LAUNCH_FAILED_NO_RESOLVE_LINK. */ void FindAppTester::FindAppTestB11() { BRoster roster; system((string("ln -s ") + testLink1 + " " + testLink1).c_str()); entry_ref linkRef(ref_for_path(testLink1, false)); entry_ref ref; CHK(roster.FindApp(&linkRef, &ref) == B_LAUNCH_FAILED_NO_RESOLVE_LINK); } /* status_t FindApp(entry_ref *ref, entry_ref *app) const @case 12 ref is valid and refers to a link to void @results Should return B_LAUNCH_FAILED_NO_RESOLVE_LINK. */ void FindAppTester::FindAppTestB12() { BRoster roster; system((string("ln -s ") + testFile1 + " " + testLink1).c_str()); entry_ref linkRef(ref_for_path(testLink1, false)); entry_ref ref; CHK(roster.FindApp(&linkRef, &ref) == B_LAUNCH_FAILED_NO_RESOLVE_LINK); } Test* FindAppTester::Suite() { TestSuite* SuiteOfTests = new TestSuite; ADD_TEST4(BRoster, SuiteOfTests, FindAppTester, FindAppTestA1); ADD_TEST4(BRoster, SuiteOfTests, FindAppTester, FindAppTestA2); ADD_TEST4(BRoster, SuiteOfTests, FindAppTester, FindAppTestA3); ADD_TEST4(BRoster, SuiteOfTests, FindAppTester, FindAppTestB1); ADD_TEST4(BRoster, SuiteOfTests, FindAppTester, FindAppTestB2); ADD_TEST4(BRoster, SuiteOfTests, FindAppTester, FindAppTestB3); ADD_TEST4(BRoster, SuiteOfTests, FindAppTester, FindAppTestB4); ADD_TEST4(BRoster, SuiteOfTests, FindAppTester, FindAppTestB5); ADD_TEST4(BRoster, SuiteOfTests, FindAppTester, FindAppTestB6); ADD_TEST4(BRoster, SuiteOfTests, FindAppTester, FindAppTestB7); ADD_TEST4(BRoster, SuiteOfTests, FindAppTester, FindAppTestB8); ADD_TEST4(BRoster, SuiteOfTests, FindAppTester, FindAppTestB9); ADD_TEST4(BRoster, SuiteOfTests, FindAppTester, FindAppTestB10); ADD_TEST4(BRoster, SuiteOfTests, FindAppTester, FindAppTestB11); ADD_TEST4(BRoster, SuiteOfTests, FindAppTester, FindAppTestB12); return SuiteOfTests; }