public StubGenerator(ScenarioInterpreter scenarioInterpreter, ImplementationHelper implementationHelper, ITextWriter suggestionWriter, ISessionContext context) { _scenarioInterpreter = scenarioInterpreter; SuggestionWriter = suggestionWriter; _context = context; _implementationHelper = implementationHelper; }
public StubGenerator(ScenarioInterpreter scenarioInterpreter, ImplementationHelper implementationHelper, ITextWriter suggestionWriter, IStoryContextFactory contextFactory) { _scenarioInterpreter = scenarioInterpreter; SuggestionWriter = suggestionWriter; _contextFactory = contextFactory; _implementationHelper = implementationHelper; }
public static void PHPInclude(ITextWriter w, string[] Modules) { foreach (var v in Modules) { PHPInclude(w, v); } }
public static void DefineScript(ITextWriter w, string[] Modules) { foreach (var v in Modules) { DefineScript(w, v); } }
static void Main(string[] args) { //initialize the Unity IoC Container and Dependency Injection Bootstrap.Init(); Initiator init = DependencyInjector.Retrieve <Initiator>(); //Instantiate the apireader and console writer objects _reader = init.GetReader(); _writer = init.GetWriter(); _reader.SetClient(uriAddress); //attempt to read from the Web API try { //Write out to the console Message 1 and 2 from the API _writer.Write(_reader.GetMessage(1).Result); _writer.Write("<Press any key to exit>"); Console.ReadLine(); _writer.Write(_reader.GetMessage(2).Result); //pause for 1 second and exit System.Threading.Thread.Sleep(1000); } //If an error occurs, print out teh error message and exit. catch (Exception ex) { _writer.Write(ex.InnerException.Message); _writer.Write("Please ensure the target API application is running, and the server is accessable"); _writer.Write("<Press any key to exit>"); Console.ReadLine(); } }
private void printCor(ITextWriter writer, int start_clock, string header) { writer.writeLine(header); int lastvalue = defaultValue; bool value_at_start_written = false; for (int i = 0; i < length; i++) { int key = clocks[i]; if (start_clock == key) { writer.writeLine(key + "=" + items[i].value); value_at_start_written = true; } else if (start_clock < key) { if (!value_at_start_written && lastvalue != defaultValue) { writer.writeLine(start_clock + "=" + lastvalue); value_at_start_written = true; } int val = items[i].value; writer.writeLine(key + "=" + val); } else { lastvalue = items[i].value; } } if (!value_at_start_written && lastvalue != defaultValue) { writer.writeLine(start_clock + "=" + lastvalue); } }
public JobQueueService(IJobQueueRepository jobQueueRepository, IProjectRepository projectRepository, IJobCounterService jobCounterService, ITextWriter textWriter) { _jobQueueRepository = jobQueueRepository; _projectRepository = projectRepository; _jobCounterService = jobCounterService; _textWriter = textWriter; }
public SdkAcquirer(HttpClient httpClient, ITextWriter textWriter, IInstallerLauncher installerLauncher, IPlatformIdentifier platformIdentifier) { _httpClient = httpClient; _textWriter = textWriter; _installerLauncher = installerLauncher; _platformIdentifier = platformIdentifier; }
public void PluginLoaderLogger_SafeSetWriter_Test() { // Arrange var pluginLoaderLogger = CreatePluginLoaderLogger(); // Act ITextWriter[] textWriterArray = new ITextWriter[15]; Parallel.Invoke( () => textWriterArray[0] = pluginLoaderLogger.SafeSetWriter(), () => textWriterArray[1] = pluginLoaderLogger.SafeSetWriter(), () => textWriterArray[2] = pluginLoaderLogger.SafeSetWriter(), () => textWriterArray[3] = pluginLoaderLogger.SafeSetWriter(), () => textWriterArray[4] = pluginLoaderLogger.SafeSetWriter(), () => textWriterArray[5] = pluginLoaderLogger.SafeSetWriter(), () => textWriterArray[6] = pluginLoaderLogger.SafeSetWriter(), () => textWriterArray[7] = pluginLoaderLogger.SafeSetWriter(), () => textWriterArray[8] = pluginLoaderLogger.SafeSetWriter(), () => textWriterArray[9] = pluginLoaderLogger.SafeSetWriter(), () => textWriterArray[10] = pluginLoaderLogger.SafeSetWriter(), () => textWriterArray[11] = pluginLoaderLogger.SafeSetWriter(), () => textWriterArray[12] = pluginLoaderLogger.SafeSetWriter(), () => textWriterArray[13] = pluginLoaderLogger.SafeSetWriter(), () => textWriterArray[14] = pluginLoaderLogger.SafeSetWriter() ); var expected = pluginLoaderLogger.Writer; // Assert foreach (var textWriter in textWriterArray) { Assert.AreEqual(expected, textWriter); } _MockRepository.VerifyAll(); }
private List <VsqHandle> writeEventListCor(ITextWriter writer, int eos) { List <VsqHandle> handles = buildHandleList(); writer.writeLine("[EventList]"); List <VsqEvent> temp = new List <VsqEvent>(); foreach (var @event in Events.iterator()) { temp.Add(@event); } temp.Sort(); int i = 0; while (i < temp.Count) { VsqEvent item = temp[i]; if (!item.ID.Equals(VsqID.EOS)) { string ids = "ID#" + PortUtil.formatDecimal("0000", item.ID.value); int clock = temp[i].Clock; while (i + 1 < temp.Count && clock == temp[i + 1].Clock) { i++; ids += ",ID#" + PortUtil.formatDecimal("0000", temp[i].ID.value); } writer.writeLine(clock + "=" + ids); } i++; } writer.writeLine(eos + "=EOS"); return(handles); }
/// <summary> /// Input dictionary and text matching with result writting to Output in accordance with the formatting /// </summary> public void Check(ITextWriter writer, INeighborsFormater formater, int maxDistance) { this.writer = writer; this.formater = formater; CreateComponent(this.dictionaryBuilder); CreateComponent(this.textBuilder); IText text = (IText)this.textBuilder.GetResult(); IWordDictionary dictionary = (IWordDictionary)this.dictionaryBuilder.GetResult(); for (int i = 0; i != text.LinesCount; i++) { var textLine = text.GetLine(i, out int[] whitespaces); for (int j = 0; j != textLine.Length; j++) { Word word = textLine[j]; var neighbors = dictionary.FindNearestСoincidence(word, maxDistance); var formatedNeighbors = this.formater.FormatNeighbors(word, neighbors); Word editedWord = new Word(formatedNeighbors); textLine[j] = editedWord; } this.writer.WriteLine(textLine, whitespaces); } }
/// <summary> /// Initializes a new instance of the <see cref="CsvWriter"/> class. /// </summary> /// <param name="textWriter">The <see cref="ITextWriter"/> to take ownership of.</param> /// <param name="format">The <see cref="CsvFormat"/> to use.</param> public CsvWriter( ITextWriter textWriter, CsvFormat format ) { Ensure.That(textWriter).NotNull(); Ensure.That(format).NotNull(); this.csvFormat = format; this.tw = textWriter; }
public CSVWriter(ITextWriter writer) { if (writer == null) { throw new ArgumentNullException(nameof(writer), "Please provide a valid text writer."); } _writer = writer; }
public BenchmarkConfiguration(IBenchmarkConfiguration benchmarkConfiguration) { BenchmarkManager = benchmarkConfiguration?.BenchmarkManager ?? throw new ArgumentNullException(nameof(benchmarkConfiguration.BenchmarkManager)); PerfCollector = benchmarkConfiguration?.PerfCollector ?? throw new ArgumentNullException(nameof(benchmarkConfiguration.PerfCollector)); TimeSpan = benchmarkConfiguration?.TimeSpan ?? BenchmarkGlobalSettings.TestingTimeSpan; Spins = benchmarkConfiguration?.Spins ?? BenchmarkGlobalSettings.TestingSpins; TextWriter = benchmarkConfiguration?.TextWriter; }
public SingleSolverBatchSolveComponent(ITextWriter report, ITextWriter progress) { Report = report; Progress = progress; Repository = null; Tracking = null; StopOnConsecutiveFails = 5; SkipPuzzlesWithSolutions = false; }
protected ATextWriterInstaller( ITextWriter ancestor, ITextWriterReplicatorManager replicatorManager, T textWriterOfT, DisposeAncestor disposeAncestor) : base(ancestor, replicatorManager, textWriterOfT, disposeAncestor) { TextWriterOfT = textWriterOfT; }
public TextOutputSink(ITextWriter writer, bool filterResults) { _textWriter = writer; _filterResults = filterResults; // If a command doesn't customize its output, the default text outputter will be used _defaultTextSink = new DefaultTextFormatter(_textWriter); InitializeCustomTextFormatters(); }
/// <summary> /// インスタンスの内容をテキストファイルに出力します /// </summary> /// <param name="sw">出力先</param> public void write(ITextWriter sw) { sw.writeLine("[Common]"); sw.writeLine("Version=" + Version); sw.writeLine("Name=" + Name); sw.writeLine("Color=" + Color); sw.writeLine("DynamicsMode=" + DynamicsMode); sw.writeLine("PlayMode=" + PlayMode); }
/// <summary> /// Constructor of the class /// </summary> /// <param name="writer">nested writer</param> /// <exception cref="ArgumentNullException">if writer parameter is null</exception> protected OutputDecorator(ITextWriter writer) { if (writer == null) { throw new ArgumentNullException("writer"); } this.writer = writer; }
public override void InitializePresenter(dynamic context) { _groupCount = 0; _options = context.Options; if (_options.WriteToOutput) { _sw = _textWriter.Create(_options.OutputPath, true); } }
/// <summary> /// 初始化布局 /// </summary> /// <param name="textWriter">文本写入器</param> /// <param name="fit">自适应布局</param> public Layout(ITextWriter textWriter, bool fit) : base(textWriter) { AddClass("easyui-layout"); if (fit) { AddDataOption("fit", true); } }
public static void PHPInclude(ITextWriter e, string src) { if (!src.EndsWith(".php")) { src += ".php"; } e.WriteLine("require_once '" + src + "';"); }
public static void DefineScript(ITextWriter w, string src) { if (!src.EndsWith(".js")) { src += ".js"; } w.WriteLine("<script type='text/javascript' src='" + src + "'></script>"); }
public SingleSolverBatchSolveComponent(ITextWriter report, ITextWriter progress, ISokobanSolutionRepository?repository, ISolverRunTracking?tracking, int stopOnConsecutiveFails, bool skipPuzzlesWithSolutions) { Report = report; Progress = progress; Repository = repository; Tracking = tracking; StopOnConsecutiveFails = stopOnConsecutiveFails; SkipPuzzlesWithSolutions = skipPuzzlesWithSolutions; }
public static async Task CollectData(IPerfCounterCollectorUC perfCollector, ITextWriter textWriter) { using (var chain = File.AppendText("UnifiedConcurrencyReport.txt").InstallInto(textWriter, DisposeAncestor.Yes)) { await DataCollectorProcessor.Execute(perfCollector, chain); await chain.TextWriterOfT.FlushAsync(); } }
private void WriteException(ITextWriter report, Exception exception, int indent = 0) { report.WriteLine(" Type: {0}", exception.GetType().Name); report.WriteLine("Message: {0}", exception.Message); report.WriteLine(exception.StackTrace); if (exception.InnerException != null) { WriteException(report, exception.InnerException, indent + 1); } }
/// <summary> /// Initializes a new instance of the <see cref="JsonWriter"/> class. /// </summary> /// <param name="textWriter">The <see cref="ITextWriter"/> to take ownership of.</param> /// <param name="indent"><c>true</c> to indent the output; otherwise, <c>false</c>.</param> /// <param name="produceAscii"><c>true</c> to write only ASCII characters (and encode others using unicode escape codes); otherwise, <c>false</c>. Non printable ASCII characters are always escaped, unless handled by the JSON standard.</param> public JsonWriter( ITextWriter textWriter, bool indent = true, bool produceAscii = false ) { Ensure.That(textWriter).NotNull(); this.textWriter = textWriter; this.indent = indent; this.produceAscii = produceAscii; this.parents = new Stack<JsonToken>(); }
public async Tasks.Task <bool> Close() { bool result; if (result = this.backend.NotNull() && await this.backend.Close()) { this.backend = null; } return(result); }
public LetterGeneratorController(ICsvReader csvReader, IPremiumBuilder <Customer> customerBuilder, ITextWriter textWriter, ILogger <LetterGeneratorController> logger) { this.csvReader = csvReader; this.customerBuilder = customerBuilder; this.textWriter = textWriter; this.logger = logger; }
/// <summary> /// Writes the hash value file (filename.extension) from the content of a File. /// </summary> /// <param name="reader">The reader for the input data.</param> /// <param name="writer">The textwriter for the output.</param> /// <exception cref="ArgumentNullException"><paramref name="reader"/>is null</exception> /// <exception cref="ArgumentNullException"><paramref name="writer"/>is null</exception> public void WriteHash(ITextReader reader, ITextWriter writer) { if (writer == null) { throw new ArgumentNullException("writer"); } string hash = this.GetHashFromReader(reader); writer.Write(hash); }
private string RenderInstance(object instance, string processorName = null) { lock (this) { writer = new StringBuilderTextWriter(); Render(instance, processorName); var result = writer.ToString(); writer = null; return(result); } }
/// <summary> /// Writes the hash file (hash.extension) from a text. /// </summary> /// <param name="text">The text, null is equal as an empty string.</param> /// <param name="writer">The textwriter for the output.</param> /// <exception cref="ArgumentNullException"><paramref name="writer"/>is null</exception> public void WriteHashFromString(string text, ITextWriter writer) { if (writer == null) { throw new ArgumentNullException("writer"); } string hash = this.GetHashFromString(text); writer.Write(hash); }
public JobQueueService(IJobQueueRepository jobQueueRepository, IProjectRepository projectRepository, IUserRepository userRepository, IJobCounterService jobCounterService, IJobDefinitionService jobDefinitionService, ITextWriter textWriter, INotificationProvider notificationProvider) { _jobQueueRepository = jobQueueRepository; _projectRepository = projectRepository; _userRepository = userRepository; _jobCounterService = jobCounterService; _jobDefinitionService = jobDefinitionService; _textWriter = textWriter; _notificationProvider = notificationProvider; }
public void SetUp() { this.mockery = new Mockery(); this.algorithm = this.mockery.NewMock<IHashAlgorithm>(); this.reader = this.mockery.NewMock<ITextReader>(); this.writer = this.mockery.NewMock<ITextWriter>(); this.hashReader = this.mockery.NewMock<ITextReader>(); this.testee = new HashService(this.algorithm); }
public void SetupContext() { FakeWriter = MockRepository.GenerateMock<ITextWriter>(); Generator = new StubGenerator(new ScenarioInterpreter(new InterpreterForTypeFactory(new ExtensionMethodHandler())), new ImplementationHelper(), FakeWriter, new FakeStoryContextFactory()); TestStory = new Story("foo", "", new[] { TestHelper.BuildScenario("", new[] { "first line", "second line" }), TestHelper.BuildScenario("", new[] { "first line", "second line", "third line" }), TestHelper.BuildScenario("", new[] { "this line's weird, punctuation! should be: handled"}) }); Generator.HandleStory(TestStory); Generator.Finished(); Suggestions = (string) FakeWriter.GetArgumentsForCallsMadeOn(x => x.Write(Arg<string>.Is.Anything))[0][0]; }
/// <summary> /// Called when the object is being disposed of. Inheritors must call base.OnDispose to be properly disposed. /// </summary> /// <param name="disposing">If set to <c>true</c>, release both managed and unmanaged resources; otherwise release only the unmanaged resources.</param> protected override void OnDispose( bool disposing ) { if( disposing ) { //// dispose-only (i.e. non-finalizable) logic //// (managed, disposable resources you own) if( this.tw.NotNullReference() ) { this.tw.Close(); this.tw = null; } } //// shared cleanup logic //// (unmanaged resources) base.OnDispose(disposing); }
public void SetupContext() { FakeWriter = MockRepository.GenerateMock<ITextWriter>(); FakeResolver = MockRepository.GenerateMock<IAmbiguousMatchResolver>(); var scenarioInterpreter = new ScenarioInterpreter(new InterpreterForTypeFactory(new AssemblyRegistry()), FakeResolver, new DefaultLanguageService()); Generator = new StubGenerator(scenarioInterpreter, new ImplementationHelper(), FakeWriter, new FakeSessionContext()); TestStory = new Story("foo", "", new[] { TestHelper.BuildScenario("", new[] { "first line", "second line" }), TestHelper.BuildScenario("", new[] { "first line", "second line", "third line" }), TestHelper.BuildScenario("", new[] { "this line's weird, punctuation! should be: handled"}) }); Generator.HandleStories(new[] {TestStory}); Suggestions = (string) FakeWriter.GetArgumentsForCallsMadeOn(x => x.Write(Arg<string>.Is.Anything))[0][0]; }
public SparkResultReportGenerator(ITextWriter fileWriter, string pathToTemplateFile) { _fileWriter = fileWriter; _pathToTemplateFile = pathToTemplateFile; }
public SparkGlossaryFormatter(ITextWriter fileWriter, string pathToTemplateFile) { _fileWriter = fileWriter; _pathToTemplateFile = pathToTemplateFile; }
/// <summary> /// Releases any resources held by an open reader. /// </summary> /// <param name="writer">The writer of the value.</param> protected override void CloseWriter( ITextWriter writer ) { var valueNode = new DataStoreTextValue(this.currentValueNodeName, this.textWriter.ToString()); this.currentValueNodeName = null; this.textWriter.Clear(); this.AddChild(valueNode); }
protected override void Dispose( bool disposing ) { if( disposing ) { if( this.textWriter.NotNullReference() ) { this.textWriter.Close(); this.textWriter = null; } } base.Dispose(disposing); }
/// <summary> /// Initializes a new instance of the <see cref="XmlDataStoreWriter"/> class. /// </summary> /// <param name="textWriter">The <see cref="ITextWriter"/> to take ownership of.</param> /// <param name="indent">Determines whether to indent the xml elements.</param> public XmlDataStoreWriter( ITextWriter textWriter, bool indent = true ) : this(XmlWriter.Create(IOWrapper.Wrap(textWriter, DataStore.DefaultEncoding), new XmlWriterSettings() { Encoding = DataStore.DefaultEncoding, NewLineChars = DataStore.DefaultNewLine, Indent = indent, CloseOutput = true })) { }
/// <summary> /// Initializes a new instance of the <see cref="JsonDataStoreWriter"/> class. /// </summary> /// <param name="textWriter">The <see cref="ITextWriter"/> to take ownership of.</param> /// <param name="indent">Determines whether to indent the JSON elements.</param> public JsonDataStoreWriter( ITextWriter textWriter, bool indent = true ) : this(new JsonWriter(textWriter, indent: indent)) { }
private void CloseWriters() { if( this.currentBinaryWriter.NotNullReference() ) { this.CloseWriter(this.currentBinaryWriter); this.currentBinaryWriter = null; } if( this.currentTextWriter.NotNullReference() ) { this.CloseWriter(this.currentTextWriter); this.currentTextWriter = null; } }
public XmlReportListener(ITextWriter fileWriter) { _fileWriter = fileWriter; _doc = new XmlDocument(); _doc.LoadXml("<" + XmlNames.DocumentElement + "/>"); }
/// <summary> /// Releases any resources held by an open reader. /// </summary> /// <param name="writer">The writer of the value.</param> protected abstract void CloseWriter( ITextWriter writer );
/// <summary> /// Returns a new <see cref="LogEntrySerializer"/> instance. /// If possible, use the other method to create an instance. /// </summary> /// <param name="xmlStream">The <see cref="ITextWriter"/> to write the Xml contents to.</param> /// <returns>The new <see cref="LogEntrySerializer"/> instance created.</returns> public static LogEntrySerializer ToXmlStream( ITextWriter xmlStream ) { var writer = new XmlDataStoreWriter(xmlStream); writer.WriteObjectStart("LogEntries"); return new LogEntrySerializer(writer); }
/// <summary> /// Writes a BinaryValue or TextValue token. The writer implementation chooses which one. /// There is exactly one - binary or text - reader for each value. /// </summary> /// <param name="name">The name of the data store value.</param> /// <param name="binaryWriter">The <see cref="IBinaryWriter"/> that can be used to write the value; or <c>null</c>.</param> /// <param name="textWriter">The <see cref="ITextWriter"/> that can be used to write the value; or <c>null</c>.</param> public void WriteValue( string name, out IBinaryWriter binaryWriter, out ITextWriter textWriter ) { this.ThrowIfDisposed(); if( !DataStore.IsValidName(name) ) throw new ArgumentException("Invalid data store name!").Store("name", name); this.CloseWriters(); var isBinary = this.Write(name, isObjectStart: null); if( isBinary.HasValue ) { this.currentBinaryWriter = isBinary.Value ? this.OpenBinaryWriter() : null; this.currentTextWriter = isBinary.Value ? null : this.OpenTextWriter(); binaryWriter = this.currentBinaryWriter; textWriter = this.currentTextWriter; } else { binaryWriter = null; textWriter = null; } }
/// <summary> /// Releases any resources held by an open reader. /// </summary> /// <param name="writer">The writer of the value.</param> protected override void CloseWriter( ITextWriter writer ) { var value = this.textWriter.ToString(); this.textWriter.Clear(); if( value.Length != 0 ) { this.xmlWriter.WriteString(value); this.xmlWriter.WriteFullEndElement(); } else { this.xmlWriter.WriteEndElement(); // not a full end element, that would be equivalent to an empty data store object } }
public SparkReportListener(ITextWriter fileWriter, string pathToTemplateFile) : base(new SparkResultReportGenerator(fileWriter, pathToTemplateFile)) { }
internal ITexWriterAsTextWriter( ITextWriter textWriter, Encoding encoding ) { if( textWriter.NullReference() ) throw new ArgumentNullException("textWriter").StoreFileLine(); if( encoding.NullReference() ) throw new ArgumentNullException("encoding").StoreFileLine(); this.encoding = encoding; this.textWriter = textWriter; }
public TextInformationalMessageWriter(ITextWriter textWriter) { _textWriter = textWriter; }
/// <summary> /// Wraps the specified <see cref="ITextWriter"/>, in <see cref="TextWriter"/>. /// </summary> /// <param name="textWriter">The <see cref="ITextWriter"/> to wrap.</param> /// <param name="encoding">The encoding to report through the <see cref="TextWriter"/>.</param> /// <returns>The disposable wrapper created.</returns> public static TextWriter Wrap( ITextWriter textWriter, Encoding encoding ) { return new ITexWriterAsTextWriter(textWriter, encoding); }
/// <summary> /// Initializes a new instance of the <see cref="Base64WriterLE"/> class. /// </summary> /// <param name="textWriter">The <see cref="ITextWriter"/> being written to.</param> public Base64WriterLE( ITextWriter textWriter ) : base() { this.TextWriter = textWriter; }
/// <summary> /// Releases any resources held by an open reader. /// </summary> /// <param name="writer">The writer of the value.</param> protected override void CloseWriter( ITextWriter writer ) { var value = this.textWriter.ToString(); this.textWriter.Clear(); this.jsonWriter.WriteUnknownValue(value); }