public void GetCorrectElementTypeForArray()
{
var parser = new ArrayParser(',', typeof(int[]));
var expected = typeof(int);
Assert.AreEqual(expected, parser.ElementType);
}
public static MeasureValueBox Parse(string webPage)
{
var result = new SortedDictionary <string, object>();
var measuredValueBox = new MeasureValueBox()
{
MeasuredUtcTime = DateTime.UtcNow, PluginName = "WebPageParser"
};
var arrayParser = new ArrayParser(WebPagerReader.SelectAllElementsOfName(webPage, "td").ToArray());
result.Add("SW.MeasureTime", DateTime.Now);
arrayParser.MoveToNextElementNotEmpty(0, true);
arrayParser.MoveNext();
arrayParser.MoveToNextElementNotEmpty(0, true);
arrayParser.MoveNext();
string all = arrayParser.MoveToNextElementNotEmpty(0, true);
arrayParser.MoveNext();
result.Add("SW.All", all);
var cultureInfo = new CultureInfo("de");
result.Add("SW.ClearSky", ArrayParser.ConvertToDouble(arrayParser.SearchForExactElement("clear sky:", 1, true), cultureInfo));
result.Add("SW.RealSkyMin", ArrayParser.ConvertToDouble(arrayParser.SearchForExactElement("real sky:", 1, false), cultureInfo));
result.Add("SW.RealSkyMax", ArrayParser.ConvertToDouble(arrayParser.SearchForExactElement("real sky:", 3, false), cultureInfo));
measuredValueBox.MeasuredValues = result;
return(measuredValueBox);
}
public void GetCorrectElementTypeForIEnumerable()
{
var parser = new ArrayParser(',', typeof(IEnumerable <int>));
var expected = typeof(int);
Assert.AreEqual(expected, parser.ElementType);
}
public ArrayParserTest()
{
var dictionary = new Dictionary <string, ParameterExpression>();
var stack = new Stack <string>();
ArrayParser = new ArrayParser(dictionary, stack);
VariableParser = new VariableParser(dictionary, stack);
}
public void ParseArrayEmptyArrayStringReturnZeroItemArray()
{
const string arrayString = "";
IArrayParser target = new ArrayParser();
var actual = target.Parse(arrayString);
var expected = new string[] { };
Assert.AreEqual(expected, actual);
}
public void Parse2ItemArrayStringReturn2ItemArray()
{
const string arrayString = "{'MS.*.dll';'MS.*.exe'}";
IArrayParser target = new ArrayParser();
var actual = target.Parse(arrayString);
var expected = new string[] { "MS.*.dll", "MS.*.exe" };
Assert.AreEqual(expected, actual);
}
public void ParseItemArrayStringWithRegularExpressionReturnItemArray()
{
const string arrayString = @"{'^.+-133-3\d+-.+$'}";
IArrayParser target = new ArrayParser();
var actual = target.Parse(arrayString);
var expected = new string[] { @"^.+-133-3\d+-.+$" };
Assert.AreEqual(expected, actual);
}
public void ParseArrayQuotedSemicolonSeparationEndingWithSemiColonSuccess()
{
const string arrayString = "'12';'13';'14';'15';";
IArrayParser target = new ArrayParser();
var actual = target.Parse(arrayString);
var expected = new[] { "12", "13", "14", "15", "" };
Assert.AreEqual(expected, actual);
}
public void ParseArrayParantesis2SimpleSemicolonSeparationSuccess()
{
const string arrayString = "[12;13;14;15]";
IArrayParser target = new ArrayParser();
var actual = target.Parse(arrayString);
var expected = new[] { "12", "13", "14", "15" };
Assert.AreEqual(expected, actual);
}
public void ParseArrayParantesis1SimplePlusSeparationSuccess()
{
const string arrayString = "{12+13+14+15}";
IArrayParser target = new ArrayParser();
var actual = target.Parse(arrayString);
var expected = new[] { "12", "13", "14", "15" };
Assert.AreEqual(expected, actual);
}
public void ParseArrayNonSupportedDelimiterReturnOneItemArray()
{
const string arrayString = "12-13-14-15";
IArrayParser target = new ArrayParser();
var actual = target.Parse(arrayString);
var expected = new[] { "12-13-14-15" };
Assert.AreEqual(expected, actual);
}
public void ParseArraySemicolonSeparationCorruptThrowInvalidArrayParseExeption()
{
const string arrayString = "'123';'21';'142;'5'";
IArrayParser target = new ArrayParser();
Assert.Throws <InvalidArrayParseException>(() =>
{
var actual = target.Parse(arrayString);
});
}
public void ParseCommaSeparatedIntArray()
{
int[] expected = { 1, 2, 3, 4 };
var parser = new ArrayParser(',', typeof(int[]));
var input = "1,2,3,4";
var result = parser.Parse(input);
Assert.AreEqual(expected, result);
}
public void GetArrayParserForArray()
{
var elementType = typeof(int);
var arrayType = elementType.MakeArrayType();
var separator = ConfigurationBinderOptions.Default.ArraySeparator;
var expected = new ArrayParser(separator, elementType);
var result = ParserFactory.CreateParser(arrayType) as ArrayParser;
Assert.NotNull(result);
}
public void ParseCommaSeparatedDecimalArray()
{
var parser = new ArrayParser(',', typeof(decimal[]));
var input = "1.2, 3.4, 4.893";
decimal[] expected = { 1.2m, 3.4m, 4.893m };
var result = parser.Parse(input);
Assert.AreEqual(expected, result);
}
public void ThrowParsingExceptionOnMixedInput()
{
var parser = new ArrayParser(',', typeof(int[]));
var input = "1,abc,3,4";
var targetType = typeof(int[]);
var ex = Assert.Throws <ParsingException>(() => parser.Parse(input));
Assert.That(ex.Input, Is.EqualTo(input));
Assert.That(ex.TargetType, Is.EqualTo(targetType));
}
public void ArrayParser_ConvertData_PassStringWithOneEmptyValue_ThrowArgumentNullException()
{
//
// Arrange.
//
var arrayParser = new ArrayParser <bool>();
string dataToConvert = "true,;false/true|false";
//
// Assert.
//
Assert.ThrowsException <ArgumentNullException>(() => arrayParser.ConvertData(dataToConvert));
}
public void ArrayParser_ConvertData_PassNullContent_ThrowArgumentNullException()
{
//
// Arrange.
//
var arrayParser = new ArrayParser <bool>();
string dataToConvert = null;
//
// Assert.
//
Assert.ThrowsException <ArgumentNullException>(() => arrayParser.ConvertData(dataToConvert));
}
private ReadOnlySpan <char> TryParseContent(out JsonObjectType type)
{
type = JsonObject.GetType(ref content);
int separatorIndex = ArrayParser.GetNextArraySeparatorIndex(ref content, type);
ReadOnlySpan <char> result = content.Slice(0, separatorIndex);
content = content.Slice(content.GetContentStartIndex(separatorIndex));
result = Parser.TryParse(ref result, out type);
return(result);
}
public static void Test()
{
ArrayParser parser = new ArrayParser(tokens);
DataObjectArray data = parser.Parse();
DataObjectArray sample = ((DataObjectArray)data[0])[0] as DataObjectArray;
if (data.Count == 4)
{
Debug.Log("[TEST]: Scripting/ArrayParser_Test - Expected result achieved. Sample: " + sample.GetDataRaw());
}
else
{
Debug.Log("Shit went wrong. Expected : 4, got : " + data.Count);
}
}
public void ThrowCorrectInnerException()
{
var parser = new ArrayParser(',', typeof(int[]));
var input = "1,abc,3,4";
var targetType = typeof(int[]);
var ex = Assert.Throws <ParsingException>(() => parser.Parse(input));
var innerException = ex.InnerException as ParsingException;
Assert.NotNull(innerException);
Assert.That(innerException.TargetType == typeof(int));
Assert.That(innerException.Input == "abc");
}
private void button4_Click(object sender, EventArgs e)
{
listBox2.Items.Clear();
string str1 = textBox1.Text; //Берём строку с массивом из textBox
string[] strArr = ArrayParser.StrToArr(str1); //Вызываем метод преобразования строки в массив
foreach (string str2 in strArr) //Проверка, что массив состоит только из цифр
{
if (!ArrayParser.IsNumberContains(str2))
{
MessageBox.Show("Массив должен состоять из целых чисел");
listBox2.Text = string.Empty;
return;
}
}
int[] intArr = ArrayParser.StrArrToIntArr(strArr); //Преобразуем string массив в int массив
if (!Check.CheckArrayDimension(intArr)) //Проверяем, что в массиве 10 чисел
{
MessageBox.Show("Количество элементов в массиве меньше десяти");
listBox2.Text = string.Empty;
return;
}
else if (!Check.CheckCapacity(intArr)) //Проверяем разрядность элементов массива
{
MessageBox.Show("Разрядность элемента массива должна быть не меньше 4");
listBox2.Text = string.Empty;
return;
}
else if (!Check.CheckPositiveNumber(intArr)) //Проверяем, что массив состоит из положительных элементов
{
MessageBox.Show("Массив должен состоять из положительных чисел");
listBox2.Text = string.Empty;
return;
}
else
{
foreach (int num in intArr)
{
if (NewMassMore.IsSimple(num) && NewMassMore.IsMore(num))
{
listBox2.Items.Add(num);
}
}
}
}
public void ParseCommaSeparatedGuidArray()
{
var parser = new ArrayParser(',', typeof(Guid[]));
string[] guids =
{
"af8cecf7-45ab-4666-9427-cfbd3ab34bb9",
"724f5817-7f9a-4219-9fbe-e83621e4a733",
"8bc122f8-fba8-43de-968c-ec335ea24b1d"
};
var input = string.Join(",", guids);
var expected = guids.Select(x => Guid.Parse(x)).ToArray();
Assert.AreEqual(parser.Parse(input), expected);
}
public static void Test()
{
string testArrayFromFile = File.ReadAllText(Application.streamingAssetsPath + "/test.array");
Lexer lexer = new Lexer();
List <Token> toks = lexer.Lex(testArrayFromFile);
ArrayParser parser = new ArrayParser(toks);
DataObjectArray array = parser.Parse();
Vector4[] vecs = Conversion.VectorArrayFromDataObjectArray(array);
if (vecs[0].w == 0.5f && vecs[1].z == 1.5f)
{
Debug.Log("[TEST]: Scripting/Conversion_Test - Expected result achieved. Sample: " + vecs[1]);
}
else
{
throw new System.Exception("Shit went horribly wrong yet again");
}
}
public static MeasureValueBox Parse(string webPage)
{
var result = new SortedDictionary <string, object>();
var measuredValueBox = new MeasureValueBox()
{
MeasuredUtcTime = DateTime.UtcNow,
PluginName = "Kostal"
};
ArrayParser arrayParser = new ArrayParser(WebPagerReader.SelectAllElementsOfName(webPage, "td").ToArray());
result.Add("PV.MeasureTime", DateTime.Now);
string typeAndName = arrayParser.MoveToNextElementNotEmpty(0, true);
string[] parseName = typeAndName.Split('\n');
string piko = string.Empty;
string name = string.Empty;
if (parseName.Length == 3)
{
piko = parseName[0].Trim();
name = parseName[2].Trim();
}
result.Add("PV.PikoType", piko);
result.Add("PV.Name", name);
result.Add("PV.CurrentACPower", ArrayParser.ConvertToInt(arrayParser.SearchForExactElement("aktuell", 1, true)));
result.Add("PV.ProducedEnergy", ArrayParser.ConvertToInt(arrayParser.SearchForExactElement("Gesamtenergie", 1, true)));
result.Add("PV.DailyEnergy", ArrayParser.ConvertToDoubleInvariantCulture(arrayParser.SearchForExactElement("Tagesenergie", 1, true)));
result.Add("PV.Status", arrayParser.SearchForExactElement("Status", 1, true));
result.Add("PV.String1Voltage", ArrayParser.ConvertToInt(arrayParser.SearchForExactElement("Spannung", 1, true)));
result.Add("PV.L1Voltage", ArrayParser.ConvertToInt(arrayParser.SearchForExactElement("Spannung", 1, true)));
result.Add("PV.String1Current", ArrayParser.ConvertToDoubleInvariantCulture(arrayParser.SearchForExactElement("Strom", 1, true)));
result.Add("PV.L1Power", ArrayParser.ConvertToInt(arrayParser.SearchForExactElement("Leistung", 1, true)));
result.Add("PV.String2Voltage", ArrayParser.ConvertToInt(arrayParser.SearchForExactElement("Spannung", 1, true)));
result.Add("PV.L2Voltage", ArrayParser.ConvertToInt(arrayParser.SearchForExactElement("Spannung", 1, true)));
result.Add("PV.String2Current", ArrayParser.ConvertToDoubleInvariantCulture(arrayParser.SearchForExactElement("Strom", 1, true)));
result.Add("PV.L2Power", ArrayParser.ConvertToInt(arrayParser.SearchForExactElement("Leistung", 1, true)));
result.Add("PV.L3Voltage", ArrayParser.ConvertToInt(arrayParser.SearchForExactElement("Spannung", 1, true)));
result.Add("PV.L3Power", ArrayParser.ConvertToInt(arrayParser.SearchForExactElement("Leistung", 1, true)));
measuredValueBox.MeasuredValues = result;
return(measuredValueBox);
}
public static void Main()
{
string[] args = Console.ReadLine()
.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
ArrayParser parser = new ArrayParser();
int[] dimensions = parser.IntegersParser(args);
int rows = dimensions[0];
int cols = dimensions[1];
MatrixGenerator matrixGenerator = new MatrixGenerator();
MatrixOperator matrixOperator = new MatrixOperator();
int[,] matrix = matrixGenerator.GenerateIntegersMatrix(rows, cols);
string command = null;
long sum = 0;
while ((command = Console.ReadLine()) != "Let the Force be with you")
{
string[] ivoArgs = command.Split();
int[] ivoCoordinates = parser.IntegersParser(ivoArgs);
string[] evilArgs = Console.ReadLine().Split();
int[] evilCoordinates = parser.IntegersParser(evilArgs);
int evilRow = evilCoordinates[0];
int evilCol = evilCoordinates[1];
matrixOperator.DeleteElementsFromBottomRightToUpperLeft(matrix, evilRow, evilCol);
int ivoRow = ivoCoordinates[0];
int ivoCol = ivoCoordinates[1];
sum += matrixOperator.SumElementsFromBottomLeftToUpperRight(matrix, ivoRow, ivoCol);
}
Console.WriteLine(sum);
}
public void ArrayParser_ConvertData_PassStringWithBoolValues_GetArrayOfBoolValues()
{
//
// Arrange.
//
var arrayParser = new ArrayParser <bool>();
string dataToConvert = "true, false;false/true|false";
var expectedArray = new bool[] { true, false, false, true, false };
bool isArrayParsedCorrectly;
//
// Act.
//
var actualArray = arrayParser.ConvertData(dataToConvert);
isArrayParsedCorrectly = actualArray.SequenceEqual(expectedArray);
//
// Assert.
//
Assert.IsTrue(isArrayParsedCorrectly);
}
public void TestMethodStrArrToIntArr()
{
CollectionAssert.AreEqual(new int[] { 123, 45, 6, 789, 3 }, ArrayParser.StrArrToIntArr(new string[] { "123", "45", "6", "789", "3" }));
CollectionAssert.AreEqual(new int[] { 1, 2, 3, 4, 5 }, ArrayParser.StrArrToIntArr(new string[] { "1", "2", "3", "4", "5" }));
}
public void TestMethodStrToArr()
{
CollectionAssert.AreEqual(new string[] { "123", "45", "6", "789", "3" }, ArrayParser.StrToArr("123 45 6 789 3"));
CollectionAssert.AreEqual(new string[] { "1", "2", "3", "4", "5" }, ArrayParser.StrToArr("1 2 3 4 5"));
}
public void TestMethodIsNumberContains(string str, bool expected)
{
Assert.AreEqual(expected, ArrayParser.IsNumberContains(str));
}