// Test nsIFile::Normalize and native path setting/getting static bool TestNormalizeNativePath(nsIFile* aBase, nsIFile* aStart) { gFunction = "TestNormalizeNativePath"; nsCOMPtr<nsIFile> file = NewFile(aStart); if (!file) return false; nsCAutoString path; nsresult rv = file->GetNativePath(path); VerifyResult(rv, "GetNativePath"); path.Append(FixName("/./..")); rv = file->InitWithNativePath(path); VerifyResult(rv, "InitWithNativePath"); rv = file->Normalize(); VerifyResult(rv, "Normalize"); rv = file->GetNativePath(path); VerifyResult(rv, "GetNativePath (after normalization)"); nsCAutoString basePath; rv = aBase->GetNativePath(basePath); VerifyResult(rv, "GetNativePath (base)"); if (!path.Equals(basePath)) { fail("%s Incorrect normalization"); return false; } return true; }
// Test nsIFile::Remove, verifying that the file does not exist and did before static bool TestRemove(nsIFile* aBase, const char* aName, bool aRecursive) { gFunction = "TestDelete"; nsCOMPtr<nsIFile> file = NewFile(aBase); if (!file) return false; nsCString name = FixName(aName); nsresult rv = file->AppendNative(name); if (!VerifyResult(rv, "AppendNative")) return false; bool exists; rv = file->Exists(&exists); if (!VerifyResult(rv, "Exists (before)")) return false; if (!exists) { fail("%s File %s does not exist", gFunction, name.get()); return false; } rv = file->Remove(aRecursive); if (!VerifyResult(rv, "Remove")) return false; rv = file->Exists(&exists); if (!VerifyResult(rv, "Exists (after)")) return false; if (exists) { fail("%s File %s was not removed", gFunction, name.get()); return false; } return true; }
void CopyTest(const char *testFile, const char *targetDir) { printf("start copy test\n"); nsresult rv; nsCOMPtr<nsILocalFile> file = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv); if (NS_FAILED(rv) || (!file)) { printf("create nsILocalFile failed\n"); return; } rv = file->InitWithNativePath(nsDependentCString(testFile)); VerifyResult(rv); nsCOMPtr<nsILocalFile> dir = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv); if (NS_FAILED(rv) || (!dir)) { printf("create nsILocalFile failed\n"); return; } rv = dir->InitWithNativePath(nsDependentCString(targetDir)); VerifyResult(rv); rv = file->CopyTo(dir, EmptyString()); VerifyResult(rv); printf("end copy test\n"); }
// Test nsIFile::Create, verifying that the file exists and did not exist before, // and leaving it there for future tests static bool TestCreate(nsIFile* aBase, const char* aName, int32_t aType, int32_t aPerm) { gFunction = "TestCreate"; nsCOMPtr<nsIFile> file = NewFile(aBase); if (!file) return false; nsCString name = FixName(aName); nsresult rv = file->AppendNative(name); if (!VerifyResult(rv, "AppendNative")) return false; bool exists; rv = file->Exists(&exists); if (!VerifyResult(rv, "Exists (before)")) return false; if (exists) { fail("%s File %s already exists", gFunction, name.get()); return false; } rv = file->Create(aType, aPerm); if (!VerifyResult(rv, "Create")) return false; rv = file->Exists(&exists); if (!VerifyResult(rv, "Exists (after)")) return false; if (!exists) { fail("%s File %s was not created", gFunction, name.get()); return false; } return true; }
static already_AddRefed<nsIFile> NewFile(nsIFile* aBase) { nsresult rv; nsCOMPtr<nsIFile> file = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv); VerifyResult(rv, "Creating nsIFile"); rv = file->InitWithFile(aBase); VerifyResult(rv, "InitWithFile"); return file.forget(); }
/** Opens an input file, trying multiple times if necessary. */ FArchive* OpenInputFile() { FArchive* InputFile = nullptr; bool bFirstOpenTry = true; while(!InputFile && !GIsRequestingExit) { // Try to open the input file that we are going to process if (CommunicationMode == ThroughFile) { InputFile = IFileManager::Get().CreateFileReader(*InputFilePath,FILEREAD_Silent); } else { #if PLATFORM_SUPPORTS_NAMED_PIPES check(IsUsingNamedPipes()); //UE_LOG(LogShaders, Log, TEXT("Opening Pipe %s\n"), *InputFilePath); //FPlatformMisc::LowLevelOutputDebugStringf(TEXT("*** Trying to open pipe %s\n"), *InputFilePath); if (Pipe.Create(InputFilePath, false, false)) { //FPlatformMisc::LowLevelOutputDebugStringf(TEXT("\tOpened!!!\n")); // Read the total number of bytes int32 TransferSize = 0; VerifyResult(Pipe.ReadInt32(TransferSize)); // Prealloc and read the full buffer TransferBufferIn.Empty(TransferSize); TransferBufferIn.AddUninitialized(TransferSize); //UE_LOG(LogShaders, Log, TEXT("Reading Buffer\n")); VerifyResult(Pipe.ReadBytes(TransferSize, TransferBufferIn.GetData())); return new FMemoryReader(TransferBufferIn); } double DeltaTime = FPlatformTime::Seconds(); if (DeltaTime - LastConnectionTime > 20.0f) { // If can't connect for more than 20 seconds, let's exit FPlatformMisc::RequestExit(false); } #endif // PLATFORM_SUPPORTS_NAMED_PIPES } if(!InputFile && !bFirstOpenTry) { CheckExitConditions(); // Give up CPU time while we are waiting FPlatformProcess::Sleep(0.01f); } bFirstOpenTry = false; } return InputFile; }
void CreateUniqueTest(const char* creationPath, const char* appendPath, PRInt32 whatToCreate, PRInt32 perm) { nsresult rv; nsCOMPtr<nsILocalFile> file = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv); if (NS_FAILED(rv) || (!file)) { printf("create nsILocalFile failed\n"); return; } Banner("Creation Test"); printf("creationPath == %s\nappendPath == %s\n", creationPath, appendPath); rv = file->InitWithNativePath(nsDependentCString(creationPath)); VerifyResult(rv); printf("Appending %s\n", appendPath); rv = file->AppendNative(nsDependentCString(appendPath)); VerifyResult(rv); printf("Check For Existence\n"); PRBool exists; file->Exists(&exists); if (exists) printf("Yup!\n"); else printf("no.\n"); rv = file->CreateUnique(whatToCreate, perm); VerifyResult(rv); rv = file->Exists(&exists); VerifyResult(rv); if (!exists) { Failed("Did not create file system object!"); return; } }
void InitTest(const char* creationPath, const char* appendPath) { nsILocalFile* file = nsnull; nsresult rv = CallCreateInstance(NS_LOCAL_FILE_CONTRACTID, &file); if (NS_FAILED(rv) || (!file)) { printf("create nsILocalFile failed\n"); return; } nsCAutoString leafName; Banner("InitWithPath"); printf("creationPath == %s\nappendPath == %s\n", creationPath, appendPath); rv = file->InitWithNativePath(nsDependentCString(creationPath)); VerifyResult(rv); printf("Getting Filename\n"); rv = file->GetNativeLeafName(leafName); printf(" %s\n", leafName.get()); VerifyResult(rv); printf("Appending %s \n", appendPath); rv = file->AppendNative(nsDependentCString(appendPath)); VerifyResult(rv); printf("Getting Filename\n"); rv = file->GetNativeLeafName(leafName); printf(" %s\n", leafName.get()); VerifyResult(rv); GetPaths(file); printf("Check For Existence\n"); PRBool exists; file->Exists(&exists); if (exists) printf("Yup!\n"); else printf("no.\n"); }
// Test nsIFile::CopyToNative, verifying that the file did not exist at the new location // before and does afterward, and that it does exist at the old location too static bool TestCopy(nsIFile* aBase, nsIFile* aDestDir, const char* aName, const char* aNewName) { gFunction = "TestCopy"; nsCOMPtr<nsIFile> file = NewFile(aBase); if (!file) return false; nsCString name = FixName(aName); nsresult rv = file->AppendNative(name); if (!VerifyResult(rv, "AppendNative")) return false; bool exists; rv = file->Exists(&exists); if (!VerifyResult(rv, "Exists (before)")) return false; if (!exists) { fail("%s File %s does not exist", gFunction, name.get()); return false; } nsCOMPtr<nsIFile> newFile = NewFile(file); nsCString newName = FixName(aNewName); rv = newFile->CopyToNative(aDestDir, newName); if (!VerifyResult(rv, "MoveToNative")) return false; bool equal; rv = file->Equals(newFile, &equal); if (!VerifyResult(rv, "Equals")) return false; if (!equal) { fail("%s file object updated unexpectedly", gFunction); return false; } rv = file->Exists(&exists); if (!VerifyResult(rv, "Exists (after)")) return false; if (!exists) { fail("%s File %s was removed", gFunction, name.get()); return false; } file = NewFile(aDestDir); if (!file) return false; rv = file->AppendNative(newName); if (!VerifyResult(rv, "AppendNative")) return false; rv = file->Exists(&exists); if (!VerifyResult(rv, "Exists (new after)")) return false; if (!exists) { fail("%s Destination file %s was not created", gFunction, newName.get()); return false; } return true; }
// Test nsIFile::CreateUnique, verifying that the new file exists and if it existed before, // the new file has a different name. // The new file is left in place. static bool TestCreateUnique(nsIFile* aBase, const char* aName, int32_t aType, int32_t aPerm) { gFunction = "TestCreateUnique"; nsCOMPtr<nsIFile> file = NewFile(aBase); if (!file) return false; nsCString name = FixName(aName); nsresult rv = file->AppendNative(name); if (!VerifyResult(rv, "AppendNative")) return false; bool existsBefore; rv = file->Exists(&existsBefore); if (!VerifyResult(rv, "Exists (before)")) return false; rv = file->CreateUnique(aType, aPerm); if (!VerifyResult(rv, "Create")) return false; bool existsAfter; rv = file->Exists(&existsAfter); if (!VerifyResult(rv, "Exists (after)")) return false; if (!existsAfter) { fail("%s File %s was not created", gFunction, name.get()); return false; } if (existsBefore) { nsCAutoString leafName; rv = file->GetNativeLeafName(leafName); if (!VerifyResult(rv, "GetNativeLeafName")) return false; if (leafName.Equals(name)) { fail("%s File %s was not given a new name by CreateUnique", gFunction, name.get()); return false; } } return true; }
int func2(void* arg) { int retval=0; ThreadData* pData = (ThreadData*) arg; retval = CondWait(pData); retval = VerifyResult(pData,EINVAL); StopThread(pData); return retval; }
// Test nsIFile::OpenNSPRFileDesc with DELETE_ON_CLOSE, verifying that the file exists // and did not exist before, and leaving it there for future tests static bool TestDeleteOnClose(nsIFile* aBase, const char* aName, int32_t aFlags, int32_t aPerm) { gFunction = "TestDeleteOnClose"; nsCOMPtr<nsIFile> file = NewFile(aBase); if (!file) return false; nsCString name = FixName(aName); nsresult rv = file->AppendNative(name); if (!VerifyResult(rv, "AppendNative")) return false; bool exists; rv = file->Exists(&exists); if (!VerifyResult(rv, "Exists (before)")) return false; if (exists) { fail("%s File %s already exists", gFunction, name.get()); return false; } PRFileDesc* fileDesc; rv = file->OpenNSPRFileDesc(aFlags | nsIFile::DELETE_ON_CLOSE, aPerm, &fileDesc); if (!VerifyResult(rv, "OpenNSPRFileDesc")) return false; PRStatus status = PR_Close(fileDesc); if (status != PR_SUCCESS) { fail("%s File %s could not be closed", gFunction, name.get()); return false; } rv = file->Exists(&exists); if (!VerifyResult(rv, "Exists (after)")) return false; if (exists) { fail("%s File %s was not removed on close!", gFunction, name.get()); return false; } return true; }
// Test nsIFile::GetParent static bool TestParent(nsIFile* aBase, nsIFile* aStart) { gFunction = "TestParent"; nsCOMPtr<nsIFile> file = NewFile(aStart); if (!file) return false; nsCOMPtr<nsIFile> parent; nsresult rv = file->GetParent(getter_AddRefs(parent)); VerifyResult(rv, "GetParent"); bool equal; rv = parent->Equals(aBase, &equal); VerifyResult(rv, "Equals"); if (!equal) { fail("%s Incorrect parent", gFunction); return false; } return true; }
void GetPaths(nsILocalFile* file) { nsresult rv; nsCAutoString pathName; printf("Getting Path\n"); rv = file->GetNativePath(pathName); VerifyResult(rv); printf("filepath: %s\n", pathName.get()); }
void MoveTest(const char *testFile, const char *targetDir) { Banner("Move Test"); printf("start move test\n"); nsresult rv; nsCOMPtr<nsILocalFile> file(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID)); if (!file) { printf("create nsILocalFile failed\n"); return; } rv = file->InitWithNativePath(nsDependentCString(testFile)); VerifyResult(rv); nsCOMPtr<nsILocalFile> dir(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID)); if (!dir) { printf("create nsILocalFile failed\n"); return; } rv = dir->InitWithNativePath(nsDependentCString(targetDir)); VerifyResult(rv); rv = file->MoveToNative(dir, NS_LITERAL_CSTRING("newtemp")); VerifyResult(rv); if (NS_FAILED(rv)) { printf("MoveToNative() test Failed.\n"); } printf("end move test\n"); }
int main(int argc, char** argv) { ScopedXPCOM xpcom("nsLocalFile"); if (xpcom.failed()) return 1; nsCOMPtr<nsIFile> base; nsresult rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(base)); if (!VerifyResult(rv, "Getting temp directory")) return 1; rv = base->AppendNative(nsDependentCString("mozfiletests")); if (!VerifyResult(rv, "Appending mozfiletests to temp directory name")) return 1; // Remove the directory in case tests failed and left it behind. // don't check result since it might not be there base->Remove(true); // Now create the working directory we're going to use rv = base->Create(nsIFile::DIRECTORY_TYPE, 0700); if (!VerifyResult(rv, "Creating temp directory")) return 1; // Now we can safely normalize the path rv = base->Normalize(); if (!VerifyResult(rv, "Normalizing temp directory name")) return 1; // Initialize subdir object for later use nsCOMPtr<nsIFile> subdir = NewFile(base); if (!subdir) return 1; rv = subdir->AppendNative(nsDependentCString("subdir")); if (!VerifyResult(rv, "Appending 'subdir' to test dir name")) return 1; passed("Setup"); // Test path parsing if (TestInvalidFileName(base, "a/b")) { passed("AppendNative with invalid file name"); } if (TestParent(base, subdir)) { passed("GetParent"); } // Test file creation if (TestCreate(base, "file.txt", nsIFile::NORMAL_FILE_TYPE, 0600)) { passed("Create file"); } if (TestRemove(base, "file.txt", false)) { passed("Remove file"); } // Test directory creation if (TestCreate(base, "subdir", nsIFile::DIRECTORY_TYPE, 0700)) { passed("Create directory"); } // Test move and copy in the base directory if (TestCreate(base, "file.txt", nsIFile::NORMAL_FILE_TYPE, 0600) && TestMove(base, base, "file.txt", "file2.txt")) { passed("MoveTo rename file"); } if (TestCopy(base, base, "file2.txt", "file3.txt")) { passed("CopyTo copy file"); } // Test moving across directories if (TestMove(base, subdir, "file2.txt", "file2.txt")) { passed("MoveTo move file"); } // Test moving across directories and renaming at the same time if (TestMove(subdir, base, "file2.txt", "file4.txt")) { passed("MoveTo move and rename file"); } // Test copying across directoreis if (TestCopy(base, subdir, "file4.txt", "file5.txt")) { passed("CopyTo copy file across directories"); } // Run normalization tests while the directory exists if (TestNormalizeNativePath(base, subdir)) { passed("Normalize with native paths"); } // Test recursive directory removal if (TestRemove(base, "subdir", true)) { passed("Remove directory"); } if (TestCreateUnique(base, "foo", nsIFile::NORMAL_FILE_TYPE, 0600) && TestCreateUnique(base, "foo", nsIFile::NORMAL_FILE_TYPE, 0600)) { passed("CreateUnique file"); } if (TestCreateUnique(base, "bar.xx", nsIFile::DIRECTORY_TYPE, 0700) && TestCreateUnique(base, "bar.xx", nsIFile::DIRECTORY_TYPE, 0700)) { passed("CreateUnique directory"); } if (TestDeleteOnClose(base, "file7.txt", PR_RDWR | PR_CREATE_FILE, 0600)) { passed("OpenNSPRFileDesc DELETE_ON_CLOSE"); } gFunction = "main"; // Clean up temporary stuff rv = base->Remove(true); VerifyResult(rv, "Cleaning up temp directory"); return gFailCount > 0; }
bool CodeRefactoring::Parse() { cbEditor* editor = Manager::Get()->GetEditorManager()->GetBuiltinActiveEditor(); if (!editor) return false; const wxString targetText = GetSymbolUnderCursor(); if (targetText.IsEmpty()) return false; TokenIdxSet targetResult; const int endOfWord = editor->GetControl()->WordEndPosition(editor->GetControl()->GetCurrentPos(), true); m_NativeParser.MarkItemsByAI(targetResult, true, false, true, endOfWord); if (targetResult.empty()) { cbMessageBox(_("Symbol not found under cursor!"), _("Code Refactoring"), wxOK | wxICON_WARNING); return false; } // handle local variables bool isLocalVariable = false; TokenTree* tree = m_NativeParser.GetParser().GetTokenTree(); CC_LOCKER_TRACK_TT_MTX_LOCK(s_TokenTreeMutex) const Token* token = tree->at(*targetResult.begin()); if (token) { const Token* parent = tree->at(token->m_ParentIndex); if (parent && parent->m_TokenKind == tkFunction) isLocalVariable = true; } CC_LOCKER_TRACK_TT_MTX_UNLOCK(s_TokenTreeMutex) wxArrayString files; cbProject* project = m_NativeParser.GetProjectByEditor(editor); if (isLocalVariable || !project) files.Add(editor->GetFilename()); else { ScopeDialog scopeDlg(Manager::Get()->GetAppWindow(), _("Code Refactoring")); const int ret = scopeDlg.ShowModal(); if (ret == ScopeDialog::ID_OPEN_FILES) GetOpenedFiles(files); else if (ret == ScopeDialog::ID_PROJECT_FILES) GetAllProjectFiles(files, project); else return false; } if (files.IsEmpty()) return false; size_t count = SearchInFiles(files, targetText); if (count) count = VerifyResult(targetResult, targetText, isLocalVariable); return count != 0; }
TInt CTestCondwait::TestCond409() { int errsum=0, err = 0; int retval = 0; ThreadData lThreadData; sem_t lSignalSemaphore; sem_t lSuspendSemaphore; sem_t lTestSemaphore; pthread_mutex_t lTestMutex; pthread_cond_t lTestCondVar; pthread_condattr_t lCondAttr; pthread_mutexattr_t lTestMutexAttr; pthread_mutexattr_t defaultattr; pthread_mutexattr_t errorcheckattr; pthread_mutexattr_t recursiveattr; pthread_mutexattr_init(&defaultattr); pthread_mutexattr_init(&errorcheckattr); pthread_mutexattr_init(&recursiveattr); pthread_mutexattr_settype(&errorcheckattr,PTHREAD_MUTEX_ERRORCHECK); pthread_mutexattr_settype(&recursiveattr,PTHREAD_MUTEX_RECURSIVE); pthread_mutex_t l_staticmutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t l_errorcheckmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP; pthread_mutex_t l_recursivemutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; pthread_cond_t l_staticcondvar = PTHREAD_COND_INITIALIZER; CommonData lCommonData; lCommonData.iStaticMutex = &l_staticmutex; lCommonData.iErrorCheckMutex = &l_errorcheckmutex; lCommonData.iRecursiveMutex = &l_recursivemutex; lCommonData.iStaticCondVar = &l_staticcondvar; retval = sem_init(&lSignalSemaphore,0,0); if(retval != 0) { return retval; } retval = sem_init(&lSuspendSemaphore,0,0); if(retval != 0) { return retval; } lThreadData.iSignalSemaphore = &lSignalSemaphore; lThreadData.iSuspendSemaphore = &lSuspendSemaphore; lThreadData.iTestSemaphore = &lTestSemaphore; lThreadData.iTestMutex = &lTestMutex; lThreadData.iTestMutexAttr = &lTestMutexAttr; lThreadData.iTestCondVar = &lTestCondVar; lThreadData.iDefaultAttr = &defaultattr; lThreadData.iErrorcheckAttr = &errorcheckattr; lThreadData.iRecursiveAttr = &recursiveattr; lThreadData.iCondAttr = &lCondAttr; for (int loop = 0; loop < EThreadMain; loop++) { g_spinFlag[loop] = true; } lThreadData.iSuspending = false; lThreadData.iSpinCounter = 0; lThreadData.iCurrentCommand = -1; lThreadData.iSelf = EThreadMain; lThreadData.iValue = 0; lThreadData.iRetValue = 0; lThreadData.ierrno = 0; lThreadData.iExpectederrno = 0; lThreadData.iTimes = 0; lThreadData.iStopped = false; lThreadData.iCommonData = &lCommonData; retval = CondInit(&lThreadData); retval = CondWait(&lThreadData); retval = VerifyResult(&lThreadData,EINVAL); retval = CondDestroy(&lThreadData); StopThread(&lThreadData); err = pthread_cond_destroy(&l_staticcondvar); if(err != EINVAL) { errsum += err; } err = pthread_mutex_destroy(&l_recursivemutex); if(err != EINVAL) { errsum += err; } err = pthread_mutex_destroy(&l_errorcheckmutex); if(err != EINVAL) { errsum += err; } err = pthread_mutex_destroy(&l_staticmutex); if(err != EINVAL) { errsum += err; } err = pthread_mutexattr_destroy(&recursiveattr); if(err != EINVAL) { errsum += err; } err = pthread_mutexattr_destroy(&errorcheckattr); if(err != EINVAL) { errsum += err; } err = pthread_mutexattr_destroy(&defaultattr); if(err != EINVAL) { errsum += err; } err = sem_destroy(&lSignalSemaphore); if(err != EINVAL) { errsum += err; } err = sem_destroy(&lSuspendSemaphore); if(err != EINVAL) { errsum += err; } return retval+errsum; }
void Loop() { UE_LOG(LogShaders, Log, TEXT("Entering job loop")); while(true) { TArray<FJobResult> JobResults; // Read & Process Input { FArchive* InputFilePtr = OpenInputFile(); if(!InputFilePtr) { break; } UE_LOG(LogShaders, Log, TEXT("Processing shader")); LastCompileTime = FPlatformTime::Seconds(); ProcessInputFromArchive(InputFilePtr, JobResults); // Close the input file. delete InputFilePtr; } // Prepare for output FArchive* OutputFilePtr = CreateOutputArchive(); check(OutputFilePtr); WriteToOutputArchive(OutputFilePtr, JobResults); // Close the output file. delete OutputFilePtr; #if PLATFORM_MAC || PLATFORM_LINUX // Change the output file name to requested one IFileManager::Get().Move(*OutputFilePath, *TempFilePath); #endif #if PLATFORM_SUPPORTS_NAMED_PIPES if (CommunicationMode == ThroughNamedPipeOnce || CommunicationMode == ThroughNamedPipe) { VerifyResult(Pipe.WriteInt32(TransferBufferOut.Num()), TEXT("Writing Transfer Size")); VerifyResult(Pipe.WriteBytes(TransferBufferOut.Num(), TransferBufferOut.GetData()), TEXT("Writing Transfer Buffer")); //FPlatformMisc::LowLevelOutputDebugStringf(TEXT("*** Closing pipe...\n")); Pipe.Destroy(); if (CommunicationMode == ThroughNamedPipeOnce) { // Give up CPU time while we are waiting FPlatformProcess::Sleep(0.02f); break; } LastConnectionTime = FPlatformTime::Seconds(); } #endif // PLATFORM_SUPPORTS_NAMED_PIPES if (GShaderCompileUseXGE) { // To signal compilation completion, create a zero length file in the working directory. WriteXGESuccessFile(*WorkingDirectory); // We only do one pass per process when using XGE. break; } } UE_LOG(LogShaders, Log, TEXT("Exiting job loop")); }