private void SaveMaterialContentFromFile(MaterialContent content) { SourceFileInfo.NullCheck("SourceFileInfo"); if (CheckSourceFileExists) { ExceptionHelper.FalseThrow(SourceFileInfo.Exists, string.Format(Resources.FileNotFound, SourceFileInfo.Name)); } if (SourceFileInfo.Exists) { content.FileSize = SourceFileInfo.Length; using (TransactionScope scope = TransactionScopeFactory.Create()) { using (FileStream stream = SourceFileInfo.OpenRead()) { MaterialContentAdapter.Instance.Update(content, stream); TransactionScopeFactory.AttachCommittedAction(new Action <TransactionEventArgs>(Current_TransactionCompleted), false); } scope.Complete(); } } }
/// <summary> /// - Gets specific encrypted source file from server. /// - Encryption and Decription using AES symetric and commonSecret derived from EC Diffie-Helman key Exchange /// - Decrypts source files /// - verifies digital signature of source code /// </summary> /// <param name="sourceFileInfo">the file to get</param> /// <returns>verified and decrypted source file or null if operation unsuccessfull</returns> private string DecryptSourceFromServer(SourceFileInfo sourceFileInfo) { byte[] dhClientPublic; byte[] dhClientPrivate; _keyGen.GenerateKeyPair(out dhClientPrivate, out dhClientPublic); string uri = (TroubleShooterClient.SERVICE_PATH + "/source"); ProtectedSourceRequest request = new ProtectedSourceRequest() { DhClientPublic = dhClientPublic, FileName = sourceFileInfo.FileName }; HttpResponseMessage response = _client.PostAsJsonAsync(uri, request).GetAwaiter().GetResult(); if (response.IsSuccessStatusCode) { ProtectedSource source = response.Content.ReadAsAsync <ProtectedSource>().GetAwaiter().GetResult(); byte[] sharedSecret = _diffieHelman.SharedSecret(dhClientPrivate, source.DhPublicServer); string decryptedSource = AesHandler.DecryptStringFromBytes_Aes(source.SourceCode, sharedSecret); if (_verifier.VerifySignature(decryptedSource, source.Signature, _signatureKey)) { return(decryptedSource); } else { return(null); } } return(null); }
private string CreateInfFile(string psFile, string jobFolder, string psFileInJobFolder, string printerName) { var psFilename = Path.GetFileName(psFile); var infFile = Path.Combine(jobFolder, psFilename + ".inf"); var jobInfo = new JobInfo(); var sourceFileInfo = new SourceFileInfo(); sourceFileInfo.Filename = psFileInJobFolder; sourceFileInfo.Author = Environment.UserName; sourceFileInfo.ClientComputer = Environment.MachineName.Replace("\\", ""); sourceFileInfo.Copies = 1; sourceFileInfo.DocumentTitle = psFile; sourceFileInfo.JobCounter = 0; sourceFileInfo.JobId = 0; sourceFileInfo.PrinterName = printerName; sourceFileInfo.SessionId = Process.GetCurrentProcess().SessionId; sourceFileInfo.TotalPages = GetNumberOfPages(psFile); sourceFileInfo.Type = JobType.PsJob; sourceFileInfo.WinStation = Environment.GetEnvironmentVariable("SESSIONNAME"); jobInfo.SourceFiles.Add(sourceFileInfo); _jobInfoManager.SaveToInfFile(jobInfo, infFile); Logger.Debug("Created inf-file for ps-file: " + infFile); return(infFile); }
private SourceFileInfo BuildSourceFileInfo(JobType type) { var sfi = new SourceFileInfo(); sfi.Filename = "MyFileName"; sfi.SessionId = 321; sfi.WinStation = "SomeStation"; sfi.Author = "Me"; sfi.ClientComputer = "MyComputer"; sfi.PrinterName = "SomePrinterName"; sfi.JobCounter = 4243; sfi.JobId = 24; sfi.DocumentTitle = "My awesome Document"; sfi.Type = type; sfi.TotalPages = 341; sfi.Copies = 3; sfi.UserTokenEvaluated = true; var userToken = new UserToken(); userToken.AddKeyValuePair("testkey", "test value"); sfi.UserToken = userToken; return(sfi); }
public async Task AddFileToArchiveAsync(SourceFileInfo fileInfo, CancellationToken cancellationToken) { if (isClosed) { throw new InvalidOperationException("Archive has been closed"); } var fileName = fileInfo.GetNameWithPath("/"); var tarHeader = new TarHeader { Name = fileName, Size = fileInfo.Length, ModTime = fileInfo.LastModified ?? DateTime.UtcNow }; Log.Debug(() => $"Adding {fileName} ({fileInfo.Length} bytes) to archive"); var tarEntry = new TarEntry(tarHeader); this.tarOutputStream.PutNextEntry(tarEntry); using (var inputStream = await fileInfo.GetStreamAsync(cancellationToken)) { if (inputStream != null && inputStream.Length > 0) { await inputStream.CopyToAsync(tarOutputStream, 81920, cancellationToken); } } this.tarOutputStream.CloseEntry(); }
/// <summary> /// Parses test unit information from the provided string /// </summary> /// <param name="value">The string to parse</param> /// <returns>Test unit information contained within value</returns> /// <exception cref="FormatException"></exception> public TestUnitInfo Parse(string value) { TestUnitInfo info = new TestUnitInfo(this.id); string[] properties = value.Split('|'); if (properties.Length > 0) { info.Name = properties[0]; } if (properties.Length > 1) { info.SourceInfo = SourceFileInfo.Parse(properties[1]); } if (properties.Length > 2) { foreach (var attribute in ParseKeyValuePairs(properties.Skip(2))) { ParseNamedAttribute(info, attribute); } } // Replace the contents of 'this' with that of 'info' Set(info); return(this); }
public void SetUp() { _tokenReplacerFactory = Substitute.For <ITokenReplacerFactory>(); _tokenReplacer = new TokenReplacer(); _tokenReplacer.AddStringToken("author", AuthorTokenValue); _tokenReplacer.AddStringToken("title", TitleTokenValue); _tokenReplacerFactory.BuildTokenReplacerWithoutOutputfiles(Arg.Any <Job>()).Returns(_tokenReplacer); _pageNumberCalculator = Substitute.For <IPageNumberCalculator>(); _userTokenExtractor = Substitute.For <IUserTokenExtractor>(); _jobDataUpdater = new JobDataUpdater(_tokenReplacerFactory, _pageNumberCalculator, _userTokenExtractor); var jobInfo = new JobInfo(); jobInfo.Metadata = new Metadata(); jobInfo.Metadata.Author = "<author>"; jobInfo.Metadata.Title = "<title>"; jobInfo.Metadata.Subject = "Test Subject"; jobInfo.Metadata.Keywords = "Test Keywords"; var sfi1 = new SourceFileInfo(); sfi1.Filename = PSFile1; jobInfo.SourceFiles.Add(sfi1); var sfi2 = new SourceFileInfo(); sfi2.Filename = PSFile2; jobInfo.SourceFiles.Add(sfi2); var profile = new ConversionProfile(); _job = new Job(jobInfo, profile, new Accounts()); _userTokenExtractor.ExtractUserTokenFromPsFile(PSFile1, _job.Profile.UserTokens.Seperator).Returns(_userToken1); _userTokenExtractor.ExtractUserTokenFromPsFile(PSFile2, _job.Profile.UserTokens.Seperator).Returns(_userToken2); }
private void AddSourceFileTokens(SourceFileInfo sourceFileInfo) { _tokenReplacer.AddStringToken("ClientComputer", sourceFileInfo.ClientComputer); _tokenReplacer.AddNumberToken("Counter", sourceFileInfo.JobCounter); _tokenReplacer.AddNumberToken("JobId", sourceFileInfo.JobId); _tokenReplacer.AddStringToken("PrinterName", sourceFileInfo.PrinterName); _tokenReplacer.AddNumberToken("SessionId", sourceFileInfo.SessionId); }
public ResolvedSource ResolveSource(SourceFileInfo sourceFileInfo, ImmutableArray <SourceLink> sourceLinks, Encoding encoding) { var pdbDocumentPath = sourceFileInfo.SourceFilePath; if (sourceFileInfo.EmbeddedText is { } embeddedText) { return(new ResolvedSource(OnDiskPath: null, embeddedText, sourceFileInfo)); }
/// <summary> /// Builds a new TestCase. /// </summary> /// <param name="name">Test Case Name</param> /// <param name="id">Test Case Id</param> /// <param name="source">Test Case source file debug information</param> /// <param name="labels">Test Case labels</param> /// <returns>this</returns> public TestFrameworkBuilder TestCase(string name, int?id, SourceFileInfo source, IEnumerable <string> labels) { TestCase testCase = new TestCase(name, this.Parent); testCase.Id = id; testCase.Source = source; testCase.Labels = labels; return(this); }
/// <summary> /// Constructs a LogEntryMemoryLeak and populates the main components /// </summary> /// <param name="leakLocation">The location of the memory leak.</param> /// <param name="leakSizeInBytes">The number of bytes leaked.</param> /// <param name="leakMemoryAllocationNumber">The memory allocation number.</param> /// <param name="leakLeakedDataContents">The memory contents which were leaked.</param> /// <returns>A new LogEntryMemoryLeak instance populated accordingly</returns> public static LogEntryMemoryLeak MakeLogEntryMemoryLeak(SourceFileInfo leakLocation, uint?leakSizeInBytes, uint?leakMemoryAllocationNumber, string leakLeakedDataContents) { return(new LogEntryMemoryLeak() { Source = leakLocation, LeakSizeInBytes = leakSizeInBytes, LeakMemoryAllocationNumber = leakMemoryAllocationNumber, LeakLeakedDataContents = leakLeakedDataContents }); }
/// <summary> /// Reads source files and returns info collection (name and version). /// </summary> /// <param name="sourceFilesDirectory">Source files path.</param> /// <returns>Source file info collection.</returns> public static IEnumerable <SourceFileInfo> GetSourceFiles(string sourceFilesDirectory) { foreach (string sourceFile in Directory.GetFiles(sourceFilesDirectory, "*.cs")) { SourceFileInfo info = new SourceFileInfo(); string sourceCode = System.IO.File.ReadAllText(sourceFile); info.FileName = Path.GetFileName(sourceFile); info.Version = GetVersionFromSource(sourceCode, info.FileName); yield return(info); } }
public void WriteSourceFileInfo_WritesCorrectSourceFileType() { var data = Data.CreateDataStorage(); var sfi = new SourceFileInfo(); sfi.Type = JobType.XpsJob; sfi.WriteSourceFileInfo(data, "0\\"); Assert.AreEqual("xps", data.GetValue("0\\SourceFileType")); }
/// <summary> /// Builds a new TestSuite. Starts a new context in which /// newly created TestUnits will be parented to this TestSuite. /// </summary> /// <param name="name">Test Suite Name</param> /// <param name="id">Test Suite Id</param> /// <param name="source">Test Suite source file debug information</param> /// <returns>this</returns> public TestFrameworkBuilder TestSuite(string name, int?id, SourceFileInfo source) { TestSuite testSuite = new TestSuite(name, this.Parent); testSuite.Id = id; testSuite.Source = source; this.Parent = testSuite; return(this); }
public void SetUp() { _sourceFileInfoDataReader = new SourceFileInfoDataReader(); _tempFileInfoFile = TempFileHelper.CreateTempFile(nameof(SourceFileInfoDataReaderTest), "TestFileInfo.inf"); _data = Data.CreateDataStorage(); _infFileIniStorage = new IniStorage(_tempFileInfoFile, Encoding.GetEncoding("Unicode")); Fixture fixture = new Fixture(); _sfi = fixture.Create <SourceFileInfo>(); }
/// <summary> /// Builds a new TestCase. /// </summary> /// <param name="name">Test Case Name</param> /// <param name="id">Test Case Id</param> /// <param name="source">Test Case source file debug information</param> /// <param name="labels">Test Case labels</param> /// <param name="enabled">Test Case enabled or disabled</param> /// <returns>this</returns> public TestFrameworkBuilder TestCase(string name, int?id, SourceFileInfo source, IEnumerable <string> labels, bool enabled) { TestCase testCase = new TestCase(name, this.Parent); testCase.Id = id; testCase.Source = source; testCase.Labels = ((labels == null)? Enumerable.Empty <string>() : labels); testCase.DefaultEnabled = enabled; return(this); }
public override void SaveMaterialContent(MaterialContent content) { SourceFileInfo.NullCheck("SourceFileInfo"); DestFileInfo.NullCheck("DestFileInfo"); if (CheckSourceFileExists) { ExceptionHelper.FalseThrow(SourceFileInfo.Exists, string.Format(Resource.FileNotFound, SourceFileInfo.Name)); } MoveFile(SourceFileInfo, DestFileInfo); }
public SymbolCodeDataProvider(CpuType type, ISymbolProvider symbolProvider, SourceFileInfo file) { //_prgRom = DebugApi.GetMemoryState(SnesMemoryType.PrgRom); _cpuType = type; _symbolProvider = symbolProvider; _file = file; _lineCount = file.Data.Length; string filename = file.Name.ToLower(); _isC = filename.EndsWith(".h") || filename.EndsWith(".c"); }
public void SetUp() { _jobInfo = new JobInfo(); var sourceFileInfo = new SourceFileInfo(); sourceFileInfo.ClientComputer = "someComputer"; sourceFileInfo.JobCounter = 3; sourceFileInfo.JobId = 14; sourceFileInfo.PrinterName = "SomePrinter"; sourceFileInfo.SessionId = 121; _jobInfo.SourceFiles.Add(sourceFileInfo); var metadata = new Metadata(); metadata.PrintJobAuthor = "someAuthor"; metadata.PrintJobName = "somePrintJobName"; metadata.Author = "someAuthor"; metadata.Title = "someTitle"; _jobInfo.Metadata = metadata; _tokenReplacerFactory = new TokenReplacerFactory(); _fileUtil = new MockFileUtil(); _fileUtil.SetInstanceToMock(); _environment = MockRepository.GenerateStub <IEnvironment>(); _environment.Stub(e => e.UserName).Return("someUser"); _environment.Stub(e => e.MachineName).Return("someMachine"); var dateTime = MockRepository.GenerateStub <IDateTime>(); dateTime.Stub(dt => dt.Now).Return(new DateTimeWrap(2000, 1, 1, 1, 1, 1)); _job = MockRepository.GenerateStub <IJob>(); _job.Stub(j => j.JobInfo).Return(_jobInfo); _job.Stub(j => j.NumberOfCopies).Return(5); _job.Stub(j => j.NumberOfPages).Return(14); _job.OutputFiles = new List <string>() { "outputFile", "test" }; var path = MockRepository.GenerateStub <IPath>(); path.Stub(p => p.GetFullPath("outputFile")).Return("fullPath"); path.Stub(p => p.GetFileNameWithoutExtension("C:\\thedir\\thefile.txt")).Return("thefile"); path.Stub(p => p.GetDirectoryName("C:\\thedir\\thefile.txt")).Return("C:\\thedir"); path.Stub(p => p.GetFileName("")).IgnoreArguments().Return("file"); _tokenReplacerFactory = new TokenReplacerFactory(dateTime, _environment, path); }
public virtual void RefreshCode(ISymbolProvider symbolProvider, SourceFileInfo file) { _symbolProvider = symbolProvider; if (file == null) { this._provider = new CodeDataProvider(CpuType.Cpu); } else { this._provider = new SymbolCodeDataProvider(CpuType.Cpu, symbolProvider, file); } }
public void SetUp() { _jobInfo = new JobInfo(); var sourceFileInfo = new SourceFileInfo(); sourceFileInfo.ClientComputer = "someComputer"; sourceFileInfo.JobCounter = 3; sourceFileInfo.JobId = 14; sourceFileInfo.PrinterName = "SomePrinter"; sourceFileInfo.SessionId = 121; _jobInfo.SourceFiles.Add(sourceFileInfo); var metadata = new Metadata(); metadata.PrintJobAuthor = "someAuthor"; metadata.PrintJobName = "somePrintJobName"; metadata.Author = "someAuthor"; metadata.Title = "someTitle"; metadata.Subject = "someSubject"; metadata.Keywords = "SomeKeyword"; _jobInfo.Metadata = metadata; _tokenReplacerFactory = new TokenReplacerFactory(new DateTimeProvider(), new EnvironmentWrap(), new PathWrap(), new PathUtil(new PathWrap(), new DirectoryWrap())); _pathUtil = Substitute.For <IPathUtil>(); _environment = MockRepository.GenerateStub <IEnvironment>(); _environment.Stub(e => e.UserName).Return("someUser"); _environment.Stub(e => e.MachineName).Return("someMachine"); var dateTime = MockRepository.GenerateStub <IDateTimeProvider>(); dateTime.Stub(dt => dt.Now()).Return(new DateTime(2000, 1, 1, 1, 1, 1)); _job = new Job(_jobInfo, new ConversionProfile(), new JobTranslations(), new Accounts()); _job.NumberOfCopies = 5; _job.NumberOfPages = 14; _job.OutputFiles = new List <string> { "outputFile", "test" }; var path = MockRepository.GenerateStub <IPath>(); path.Stub(p => p.GetFullPath("outputFile")).Return("fullPath"); path.Stub(p => p.GetFileNameWithoutExtension("C:\\thedir\\thefile.txt")).Return("thefile"); path.Stub(p => p.GetDirectoryName("C:\\thedir\\thefile.txt")).Return("C:\\thedir"); path.Stub(p => p.GetFileName("")).IgnoreArguments().Return("file"); _tokenReplacerFactory = new TokenReplacerFactory(dateTime, _environment, path, _pathUtil); }
public TestFrameworkBuilder TestSuite(string name, int?id, SourceFileInfo source, bool enabled) { TestSuite testSuite = new TestSuite(name, this.Parent); testSuite.Id = id; testSuite.Source = source; this.Parent = testSuite; testSuite.DefaultEnabled = enabled; return(this); }
/// <summary> /// Parses the <em>entire</em> test case/suite declaration /// </summary> /// <param name="splitMacro">The current source line split into tokens</param> /// <param name="sourceInfo">Source file and line information/param> /// <param name="code">The entire code split by line</param> /// <param name="line">The current source code line which is being evaluated</param> /// <returns>An array of string components which are of interest for test component evaluation</returns> private static string[] ParseTestDeclaration(string[] splitMacro, SourceFileInfo sourceInfo, string[] code, ref string line) { int newLineNumber = ScrollLines(sourceInfo.LineNumber, code, ref line); if (sourceInfo.LineNumber != newLineNumber) { // re calculate splitMacro splitMacro = SplitMacro(line); sourceInfo.LineNumber = newLineNumber; } return(splitMacro); }
private static void AssertSfiAreEqual(SourceFileInfo expectedSfi, SourceFileInfo actualSfi) { var type = typeof(SourceFileInfo); foreach (var propertyInfo in type.GetProperties()) { if (propertyInfo.PropertyType == typeof(UserToken)) { continue; } Assert.AreEqual(propertyInfo.GetValue(expectedSfi), propertyInfo.GetValue(actualSfi), $"Failed Property: {propertyInfo.Name}"); } }
private static void AssertSfiAreEqual(SourceFileInfo result, SourceFileInfo sfi) { Assert.AreEqual(result.Filename, sfi.Filename); Assert.AreEqual(result.SessionId, sfi.SessionId); Assert.AreEqual(result.WinStation, sfi.WinStation); Assert.AreEqual(result.Author, sfi.Author); Assert.AreEqual(result.ClientComputer, sfi.ClientComputer); Assert.AreEqual(result.PrinterName, sfi.PrinterName); Assert.AreEqual(result.JobCounter, sfi.JobCounter); Assert.AreEqual(result.JobId, sfi.JobId); Assert.AreEqual(result.DocumentTitle, sfi.DocumentTitle); Assert.AreEqual(result.Type, sfi.Type); Assert.AreEqual(result.Copies, sfi.Copies); Assert.AreEqual(result.UserTokenEvaluated, sfi.UserTokenEvaluated); Assert.AreEqual(result.UserToken.KeyValueDict, sfi.UserToken.KeyValueDict); }
public void WriteSourceFileInfo_WritesCorrectInfoToData() { var sfi = new SourceFileInfo(); sfi.DocumentTitle = "title"; sfi.WinStation = "winstation"; sfi.Author = "author"; var data = Data.CreateDataStorage(); sfi.WriteSourceFileInfo(data, "0\\"); Assert.AreEqual(sfi.DocumentTitle, data.GetValue("0\\DocumentTitle")); Assert.AreEqual(sfi.WinStation, data.GetValue("0\\WinStation")); Assert.AreEqual(sfi.Author, data.GetValue("0\\UserName")); // TODO extend this }
public bool SelectFile(SourceFileInfo file) { if (!_inSourceView) { ToggleView(); } foreach (SourceFileInfo fileInfo in cboSourceFile.Items) { if (fileInfo == file) { cboSourceFile.SelectedItem = fileInfo; return(true); } } return(false); }
private void AddTokensForDocumentTitle(SourceFileInfo sfi, Metadata metadata) { var titleFilename = ""; var titleFolder = ""; if (_pathUtil.IsValidRootedPath(sfi.DocumentTitle)) { titleFilename = _pathWrapSafe.GetFileNameWithoutExtension(sfi.DocumentTitle); titleFolder = _pathWrapSafe.GetDirectoryName(sfi.DocumentTitle); } else { titleFilename = metadata.PrintJobName; } _tokenReplacer.AddStringToken("InputFilename", titleFilename); _tokenReplacer.AddStringToken("InputFilePath", titleFolder); }
/// <summary> /// Creates a new TestCase object. /// </summary> /// <param name="sourceExe">Name of the project executable</param> /// <param name="sourceInfo">.cpp file path and TestCase line number</param> /// <param name="suite">The suite in which testcase is present</param> /// <param name="testCaseName">Name of the testcase</param> /// <param name="isEnabled">The enabling status of the testcase</param> /// <returns>The created TestCase object</returns> public static TestCase CreateTestCase(string sourceExe, SourceFileInfo sourceInfo, QualifiedNameBuilder suite, string testCaseName, bool isEnabled = true) { suite.Push(testCaseName); string qualifiedName = suite.ToString(); suite.Pop(); var testCase = new TestCase(qualifiedName, BoostTestExecutor.ExecutorUri, sourceExe) { CodeFilePath = sourceInfo.File, LineNumber = sourceInfo.LineNumber, DisplayName = testCaseName, }; GroupViaTraits(suite.ToString(), testCase, isEnabled); return(testCase); }
/// <summary> /// Asserts test case details /// </summary> /// <param name="unit">The test case to test</param> /// <param name="id">The expected Id of the test case</param> /// <param name="info">The expected source file information of the test case</param> /// <param name="parent">The expected parent of the test case</param> private void AssertTestCase(TestUnit unit, int id, SourceFileInfo info, TestUnit parent) { AssertTestUnit(unit, typeof(TestCase), id, parent); TestCase test = ((TestCase)unit); Assert.That(test.Children, Is.Empty); SourceFileInfo unitInfo = test.Source; if (info == null) { Assert.That(unitInfo, Is.Null); } else { Assert.That(unitInfo.File, Is.EqualTo(info.File)); Assert.That(unitInfo.LineNumber, Is.EqualTo(info.LineNumber)); } }
/// <summary> /// Appends the SourceInfo instance information to the provided StringBuilder. /// </summary> /// <param name="info">The SourceInfo instance to stringify.</param> /// <param name="sb">The StringBuilder which will host the result.</param> /// <returns>sb</returns> private static StringBuilder AppendSourceInfo(SourceFileInfo info, StringBuilder sb) { sb.Append((string.IsNullOrEmpty(info.File) ? "unknown location" : info.File)); if (info.LineNumber > -1) { sb.Append('(').Append(info.LineNumber).Append(')'); } sb.Append(": "); return sb; }
/// <summary> /// Appends the SourceInfo instance information to the provided StringBuilder. /// </summary> /// <param name="info">The SourceInfo instance to stringify.</param> /// <param name="sb">The StringBuilder which will host the result.</param> /// <returns>sb</returns> private static StringBuilder AppendSourceInfo(SourceFileInfo info, StringBuilder sb) { return sb.Append(info).Append(": "); }