private static void AssertEqualTranslatedPath(DirectoryTranslator translator, string[] expected, string[] path) { string expectedAbsolute = A(expected); string pathAbsolute = A(path); XAssert.AreEqual(expectedAbsolute.ToUpperInvariant(), translator.Translate(pathAbsolute).ToUpperInvariant()); }
private static void AssertEqualTranslatedPath(DirectoryTranslator translator, PathTable pathTable, string[] expected, string[] path) { string expectedAbsolute = A(expected); string pathAbsolute = A(path); XAssert.AreEqual(AbsolutePath.Create(pathTable, expectedAbsolute), translator.Translate(AbsolutePath.Create(pathTable, pathAbsolute), pathTable)); }
public void TestMalformedPaths() { var context = BuildXLContext.CreateInstanceForTesting(); var pathTable = context.PathTable; var translations = new[] { CreateInputTranslation(pathTable, new string[] { "K", "dbs", "sh", "dtb", "b" }, new string[] { "d", "dbs", "sh", "dtb", "0629_120346" }), }; var translator = new DirectoryTranslator(); translator.AddTranslations(translations, pathTable); translator.Seal(); // None of these paths should be mutated by DirectoryTranslator foreach (string pathToTest in new string[] { @"\??\", @"\\?\", @":", @"d", @"k", @"", }) { // Test edge cases for various paths. Note these explicitly don't go through path generation utilities because they can // massage away malformed paths that we explicitly want to test. AssertAreEqual(pathToTest, translator.Translate(pathToTest)); } }
private bool TryResolveSymlinkedPath(string path, out ExpandedAbsolutePath expandedFinalPath) { if (!FileUtilities.TryGetFinalPathNameByPath(path, out string finalPathAsString, out _, volumeGuidPath: false)) { // If the final path cannot be resolved (most common cause is file not found), we stay with the original path expandedFinalPath = default; return(false); } if (m_directoryTranslator != null) { finalPathAsString = m_directoryTranslator.Translate(finalPathAsString); } // We want to compare the final path with the parsed path, so let's go through the path table // to fully canonicalize it var success = AbsolutePath.TryCreate(m_context.PathTable, finalPathAsString, out var finalPath); if (!success) { Contract.Assume(false, $"The result of GetFinalPathNameByPath should always be a path we can parse. Original path is '{path}', final path is '{finalPathAsString}'."); } expandedFinalPath = ExpandedAbsolutePath.CreateUnsafe(finalPath, finalPathAsString); return(true); }
/// <summary> /// Translate the path based on the added translations /// </summary> public string Translate(string path) { return(m_translator.Translate(path)); }
/// <summary> /// Tries to parse input line. /// </summary> /// <remarks> /// Input line must be of the form: /// full path /// or /// full path|comma separated <see cref="PathChanges"/> /// The former assumes that changes are <see cref="PathChanges.DataOrMetadataChanged"/>. /// </remarks> private static bool TryParseInput( LoggingContext loggingContext, string input, string filePath, int lineNo, out ChangedPathInfo changedPathInfo, string sourceRoot = null, DirectoryTranslator directoryTranslator = null) { Contract.Requires(loggingContext != null); Contract.Requires(!string.IsNullOrEmpty(input)); changedPathInfo = default; string[] splitInput = input.Split(s_inputSeparator); if (splitInput.Length > 2) { Logger.Log.InvalidFormatOfInputChange(loggingContext, input, filePath, lineNo); return(false); } string changedPath = splitInput[0].Trim(); string changesStr = null; if (splitInput.Length == 2) { changesStr = splitInput[1].Trim(); } // Assume data or metadata change if unspecified. PathChanges changes = PathChanges.DataOrMetadataChanged; try { if (!Path.IsPathRooted(changedPath)) { if (string.IsNullOrEmpty(sourceRoot)) { Logger.Log.InvalidChangedPathOfInputChange(loggingContext, changedPath, filePath, lineNo); return(false); } changedPath = Path.GetFullPath(Path.Combine(sourceRoot, changedPath)); } if (directoryTranslator != null) { changedPath = directoryTranslator.Translate(changedPath); } if (!string.IsNullOrEmpty(changesStr)) { if (!Enum.TryParse(changesStr, true, out changes)) { string validKinds = string.Join(", ", ((PathChanges[])Enum.GetValues(typeof(PathChanges))).Select(c => c.ToString())); Logger.Log.InvalidChangeKindsOfInputChange(loggingContext, changesStr, filePath, lineNo, validKinds); return(false); } } } catch (ArgumentException argumentException) { Logger.Log.InvalidInputChange(loggingContext, input, filePath, lineNo, argumentException.ToString()); return(false); } changedPathInfo = new ChangedPathInfo(changedPath, changes); return(true); }