public void Parse_WithDoubleSpace_RemovesEmptySections(string commandText, int expectedSectionCount)
{
CoreParser parser = new CoreParser();
ICoreParseResult parseResult = parser.Parse(commandText, commandText.Length + 1);
Assert.Equal(expectedSectionCount, parseResult.Sections.Count);
}
private void ParseQuery(string queryString, IDictionary <string, string> dict)
{
var query = CoreParser.Split(queryString, new char[] { '?' }).Last();
if (!query.Contains('='))
{
return;
}
var queryPairs = CoreParser.Split(query, new char[] { '&' });
foreach (var queryPair in queryPairs)
{
var queryKvp = CoreParser.Split(queryPair, new char[] { '=' });
if (queryKvp.Length != 2)
{
continue;
}
var key = WebUtility.UrlDecode(queryKvp[0]);
var value = WebUtility.UrlDecode(queryKvp[1]);
dict[key] = value;
}
}
public void TestMethod_GetString()
{
IParser newStr = CoreParser.CreateInstance().ParseTxt(Path);
OneRowTxt[] result = newStr.GetValueInTxtFile();
Assert.AreEqual(result.Length, 161);
}
private void ParseRequest(string requestText)
{
var requestLines = CoreParser.Split(requestText, new[] { Environment.NewLine });
if (!requestLines.Any())
{
throw new BadRequestException();
}
var requestLine = CoreParser.Split(requestLines[0], new char[] { ' ' });
if (requestLine.Length != 3 ||
requestLine[2].ToLower() != "http/1.1")
{
throw new BadRequestException();
}
this.Method = ParseMethod(requestLine[0]);
this.Url = requestLine[1];
this.Path = this.ParsePath(this.Url);
this.ParseHeaders(requestLines);
this.ParseParameters();
this.ParseFormData(requestLines.Last());
}
public SyntaxTreeNode(string parsedText, string rest, CoreParser parserWhereWasProducted, IList <SyntaxTreeNode> children)
{
Id = Guid.NewGuid();
ParsedText = parsedText;
Rest = rest;
Parser = parserWhereWasProducted;
Children = (children is null) ? null : new ReadOnlyCollection <SyntaxTreeNode>(children);
}
public void Slice_WithVariousSliceLengths_CorrectCommandTextOutput(string commandText, int toRemove, string expectedCommandText)
{
CoreParser parser = new CoreParser();
ICoreParseResult parseResult = parser.Parse(commandText, commandText.Length);
ICoreParseResult result = parseResult.Slice(toRemove);
Assert.Equal(expectedCommandText, result.CommandText);
}
public void Slice_WithSelectedSection_SelectedSectionMoves(string commandText, int toRemove, int caretPosition, int expectedSelectedSection)
{
CoreParser parser = new CoreParser();
ICoreParseResult parseResult = parser.Parse(commandText, caretPosition);
ICoreParseResult result = parseResult.Slice(toRemove);
Assert.Equal(expectedSelectedSection, result.SelectedSection);
}
public void Slice_WithZero_ReturnsThis()
{
CoreParser parser = new CoreParser();
string commandText = "set header content-type application/json";
ICoreParseResult parseResult = parser.Parse(commandText, commandText.Length);
ICoreParseResult result = parseResult.Slice(0);
Assert.Same(parseResult, result);
}
public void Slice_WithCaretInSlicedRegion_CaretIsZero()
{
CoreParser parser = new CoreParser();
string commandText = "set header content-type application/json";
ICoreParseResult parseResult = parser.Parse(commandText, 5);
ICoreParseResult result = parseResult.Slice(2);
Assert.Equal(0, result.CaretPositionWithinCommandText);
}
public void ParseReturnsCorrectResultWhenSuccessful()
{
var builderFactories = Mock.Of <IBuilderFactories>();
var parser = new CoreParser <Step>(new ParsingData(), builderFactories);
var(failedLines, remaining, result) = parser.Parse("matched", ExpectedModifier.Source, default);
Assert.IsEmpty(failedLines);
Assert.IsEmpty(remaining);
Assert.AreEqual(new[] { ExpectedModifier }, result);
}
public ParserSerial(CoreParser internalParser, int minTimes, int maxTimes)
{
if (minTimes > maxTimes)
{
throw new ArgumentException($"The {nameof(minTimes)} argument must be less than {nameof(maxTimes)}");
}
InternalParser = internalParser;
MinTimes = minTimes;
MaxTimes = maxTimes;
}
public static ICoreParseResult Create(string commandText)
{
if (commandText == null)
{
throw new ArgumentNullException(nameof(commandText));
}
CoreParser coreParser = new CoreParser();
ICoreParseResult parseResult = coreParser.Parse(commandText, commandText.Length);
return(parseResult);
}
public void Parse_WithQuotesButNoSpaces_DoesNotCombineSections()
{
// Arrange
string commandText = "GET --response:headers \"file.txt\" --response:body \"file.txt\"";
int caretPosition = commandText.Length + 1;
CoreParser parser = new CoreParser();
int expectedSectionCount = 5;
// Act
ICoreParseResult parseResult = parser.Parse(commandText, caretPosition);
// Assert
Assert.Equal(expectedSectionCount, parseResult.Sections.Count);
}
public void ParserTests_Basic()
{
string testString = "\"this is a test\" of \"Escape\\\\Sequences\\\"\"";
CoreParser parser = new CoreParser();
ICoreParseResult result = parser.Parse(testString, 29);
Assert.Equal(3, result.Sections.Count);
Assert.Equal(2, result.SelectedSection);
Assert.Equal(0, result.SectionStartLookup[0]);
Assert.Equal(17, result.SectionStartLookup[1]);
Assert.Equal(20, result.SectionStartLookup[2]);
Assert.Equal(7, result.CaretPositionWithinSelectedSection);
Assert.Equal(29, result.CaretPositionWithinCommandText);
Assert.Equal(testString, result.CommandText);
}
public void Slice_WithTooMany_ReturnsDefaultResult()
{
CoreParser parser = new CoreParser();
string commandText = "set header content-type application/json";
ICoreParseResult parseResult = parser.Parse(commandText, commandText.Length);
ICoreParseResult result = parseResult.Slice(100);
Assert.Equal(0, result.CaretPositionWithinCommandText);
Assert.Equal(0, result.CaretPositionWithinSelectedSection);
Assert.Equal(string.Empty, result.CommandText);
Assert.Single(result.Sections);
Assert.Contains(string.Empty, result.Sections);
Assert.Equal(0, result.SelectedSection);
Assert.Single(result.SectionStartLookup);
Assert.Equal(0, result.SectionStartLookup.Single().Key);
Assert.Equal(0, result.SectionStartLookup.Single().Value);
}
private App([NotNull] Window window)
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
try
{
Window mainWindow = window ?? throw new ArgumentException(nameof(App));
ShowWindow(mainWindow);
}
catch (Exception ex)
{
Logger.Logger.Error(ex, nameof(App), "Constructor");
}
//Создание ядра для парсера
CoreParser.CreateInstance();
//Создание конфига
_ = Config.Config.Config.Con;
}
protected override void Parse(HtmlDocument doc)
{
var tables = doc.DocumentNode.Descendants().Where
(x => x.Name == "div" && x.HasClass("accordion-group"));
foreach (var t in tables)
{
var name = t.Descendants("a").First().InnerText;
foreach (var td in t.Descendants("td"))
{
foreach (var a in td.Descendants("a").Where(x => x.GetAttributeValue("target", null) == null))
{
var href = a.Attributes["href"].Value;
string stryear = href.Substring(3, href.IndexOf('i', 4) - 3);
int year = int.Parse(stryear);
Institutes.Add(new Institute(a.InnerText,
CoreParser.FromBase('/' + year.ToString() + href.Trim('.')), year).SetType(name));
}
}
}
}
private void ParseHeaders(string[] requestLines)
{
var endOfHedears = Array.IndexOf(requestLines, string.Empty);
for (int i = 1; i < endOfHedears; i++)
{
var headerLine = CoreParser.Split(requestLines[i], new char[] { ':' });
if (headerLine.Length != 2)
{
throw new BadRequestException();
}
var key = headerLine[0];
var value = headerLine[1].Trim();
this.Headers.Add(new HttpHeader(key, value));
}
if (!this.Headers.ContainsKey("Host"))
{
throw new BadRequestException();
}
}
public ParserAlternative(CoreParser firstParser, CoreParser secondParser)
{
FirstParser = firstParser;
SecondParser = secondParser;
}
public UnitTestParserTxt()
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
CoreParser.CreateInstance();
}
public ParserConcatenation(CoreParser firstParser, CoreParser secondParser)
{
FirstParser = firstParser ?? throw new ArgumentNullException(nameof(firstParser));
SecondParser = secondParser ?? throw new ArgumentNullException(nameof(secondParser));
}
public ParserOptional(CoreParser internalParser, string defaultValue = null)
{
InternalParser = internalParser;
DefaultValue = defaultValue;
}
public LoadFromFileException(Grammar grammar, CoreParser parser, string configText)
{
Message = $"{this}: parse result is null";
}
private string ParsePath(string url)
{
return(CoreParser.Split(url, new char[] { '?', '#' }).FirstOrDefault());
}
