public void ParseDynamicSessionInfo(string sessionInfo, bool isPlayerCar)
{
// Parse only session info that could have changed (driver dependent)
this.Name = ParseDriverYaml(sessionInfo, "UserName");
this.CustId = Parser.ParseInt(ParseDriverYaml(sessionInfo, "UserID"));
this.IRating = Parser.ParseInt(ParseDriverYaml(sessionInfo, "IRating"));
this.LicensLevelString = ParseDriverYaml(sessionInfo, "LicString");
this.licensLevel = Parser.ParseLicens(LicensLevelString);
this.IsSpectator = Parser.ParseInt(ParseDriverYaml(sessionInfo, "IsSpectator")) == 1;
if (isPlayerCar && (this.Car.DriverPitTrkPct <= 0 || this.Car.DriverCarMaxFuelPct <= 0 || this.Car.DriverCarFuelMaxLtr <= 0))
{
this.Car.DriverCarFuelMaxLtr = Parser.ParseFloat(YamlParser.Parse(sessionInfo, "DriverInfo:DriverCarFuelMaxLtr:"), -1.0f);
this.Car.DriverCarMaxFuelPct = Parser.ParseFloat(YamlParser.Parse(sessionInfo, "DriverInfo:DriverCarMaxFuelPct:"), -1.0f);
this.Car.DriverPitTrkPct = Parser.ParseFloat(YamlParser.Parse(sessionInfo, "DriverInfo:DriverPitTrkPct:"), -1.0f);
}
}
public void AddLight()
{
const string yaml = @"
- add: light
at: [ 50, 100, -50 ]
intensity: [ 1, 1, 1 ]";
var parser = new YamlParser();
var(world, _) = parser.LoadYaml(yaml);
var light = world.Lights[0];
Assert.Equal(new Point(50, 100, -50), light.Position);
Assert.Equal(Color.White, light.Intensity);
}
public void ServicesMustHaveUniqueNonNullPorts()
{
var input = @"
services:
- name: app
bindings:
- protocol: http
name: a
- protocol: https
name: b";
using var parser = new YamlParser(input);
var app = parser.ParseConfigApplication();
app.Validate();
}
public static Driver FromSessionInfo(string sessionInfo, int carIdx, int playerCarIdx)
{
string name;
if (!YamlParser.TryGetValue(sessionInfo, string.Format(driverYamlPath, carIdx, "UserName"), out name))
{
// Driver not found
return(null);
}
var driver = new Driver();
driver.Id = carIdx;
driver.ParseStaticSessionInfo(sessionInfo, playerCarIdx == carIdx);
driver.ParseDynamicSessionInfo(sessionInfo, playerCarIdx == carIdx);
return(driver);
}
public void IngressProtocolsShouldBeHttpOrHttps()
{
var input = @"
ingress:
- name: ingress
bindings:
- port: 8080
protocol: tls
name: a";
using var parser = new YamlParser(input);
var app = parser.ParseConfigApplication();
var exception = Assert.Throws <TyeYamlException>(() => app.Validate());
Assert.Contains(CoreStrings.IngressBindingMustBeHttpOrHttps, exception.Message);
}
public void ExtensionsTest()
{
var input = @"
extensions:
- name: dapr";
using var parser = new YamlParser(input);
var app = parser.ParseConfigApplication();
Assert.Equal("dapr", app.Extensions.Single()["name"]);
var expected = _deserializer.Deserialize <ConfigApplication>(new StringReader(input));
Assert.Equal(expected.Extensions.Count, app.Extensions.Count);
}
public void ParseIndentTest1()
{
MemoryStream stream = new MemoryStream();
StreamWriter writer = new StreamWriter(stream);
writer.WriteLine(" ");
writer.Flush();
stream.Seek(0, SeekOrigin.Begin);
using (TextReader reader = new StreamReader(stream))
{
YamlParser parser = new YamlParser(reader, null);
Assert.AreEqual(15, parser.ParseIndent(), "ParseIndentTest1#100");
Assert.AreEqual(15, parser.ParseIndent(), "ParseIndentTest1#200");
}
}
public void ParseArrayTest1()
{
MemoryStream stream = new MemoryStream();
StreamWriter writer = new StreamWriter(stream);
string expected = " ";
writer.WriteLine(expected);
writer.Flush();
stream.Seek(0, SeekOrigin.Begin);
using (TextReader reader = new StreamReader(stream))
{
YamlParser parser = new YamlParser(reader, null);
Assert.AreEqual(expected, parser.ParseArray(YamlCharacterType.Space));
}
}
public void ParseIndentTest3()
{
MemoryStream stream = new MemoryStream();
StreamWriter writer = new StreamWriter(stream);
writer.WriteLine(" ");
writer.Flush();
stream.Seek(0, SeekOrigin.Begin);
using (TextReader reader = new StreamReader(stream))
{
YamlParser parser = new YamlParser(reader, null);
Assert.IsFalse(parser.ParseIndent(5), "ParseIndentTest3#100");
Assert.IsFalse(parser.ParseIndent(10), "ParseIndentTest3#200");
Assert.IsTrue(parser.ParseIndent(15), "ParseIndentTest3#300");
}
}
public void DefineMaterialWithExtend()
{
const string yaml = @"
- define: white-material
value:
color: [ 1, 1, 1 ]
diffuse: 0.7
ambient: 0.1
specular: 0.0
reflective: 0.1
- define: blue-material
extend: white-material
value:
color: [ 0.537, 0.831, 0.914 ]";
var parser = new YamlParser();
parser.LoadYaml(yaml);
Assert.Equal(2, parser.Materials.Count);
var whiteMaterial = parser.Materials["WHITE-MATERIAL"];
var whitePattern = (SolidPattern)whiteMaterial.Pattern;
Assert.Equal(Color.White, whitePattern.Color);
Assert.Equal(0.1f, whiteMaterial.Ambient);
Assert.Equal(0.7f, whiteMaterial.Diffuse);
Assert.Equal(0, whiteMaterial.Specular);
Assert.Equal(200, whiteMaterial.Shininess);
Assert.Equal(0.1f, whiteMaterial.Reflective);
Assert.Equal(0, whiteMaterial.Transparency);
Assert.Equal(1, whiteMaterial.RefractiveIndex);
var blueMaterial = parser.Materials["BLUE-MATERIAL"];
var bluePattern = (SolidPattern)blueMaterial.Pattern;
Assert.Equal(new Color(0.537f, 0.831f, 0.914f), bluePattern.Color);
Assert.Equal(0.1f, blueMaterial.Ambient);
Assert.Equal(0.7f, blueMaterial.Diffuse);
Assert.Equal(0, blueMaterial.Specular);
Assert.Equal(200, blueMaterial.Shininess);
Assert.Equal(0.1f, blueMaterial.Reflective);
Assert.Equal(0, blueMaterial.Transparency);
Assert.Equal(1, blueMaterial.RefractiveIndex);
}
public static void verifyYaml(String sourceYaml, String expectedStdout = null)
{
StringReader test = new StringReader(sourceYaml);
YamlParser parser = new YamlParser();
List <Pnyx> toExecute = parser.parseYaml(test);
Assert.Single(toExecute);
Pnyx p = toExecute[0];
String actual;
using (p)
actual = p.processToString();
Assert.Equal(expectedStdout, actual);
}
public BrowserTest()
{
var path = $"{Utils.CurrentDirectory()}\\{@"Parser\Client\fixtures\browser.yml"}";
var parser = new YamlParser <List <BrowserFixture> >();
_fixtureData = parser.ParseFile(path);
//replace null
_fixtureData = _fixtureData.Select(f =>
{
f.client.version = f.client.version ?? "";
f.client.engine = f.client.engine ?? "";
f.client.engine_version = f.client.engine_version ?? "";
return(f);
}).ToList();
}
public void ServicesSetCorrectly()
{
var input = @"
services:
- name: appA
project: ApplicationA/ApplicationA.csproj
replicas: 2
tags:
- A
- B
external: false
image: abc
build: false
executable: test.exe
workingDirectory: ApplicationA/
args: a b c
env:
- name: POSTGRES_PASSWORD
value: ""test""
- name: POSTGRES_PASSWORD2
value: ""test2""
volumes:
- name: volume
source: /data
target: /data
bindings:
- name: test
port: 4444
connectionString: asdf
containerPort: 80
host: localhost
protocol: http
- name: appB
project: ApplicationB/ApplicationB.csproj
replicas: 2
tags:
- tC
- tD";
using var parser = new YamlParser(input);
var actual = parser.ParseConfigApplication();
var expected = _deserializer.Deserialize <ConfigApplication>(new StringReader(input));
TyeAssert.Equal(expected, actual);
}
public void MultipleIngressBindingsMustHaveNames()
{
var input = @"
ingress:
- name: ingress
bindings:
- port: 8080
protocol: http
- port: 8080
protocol: http";
using var parser = new YamlParser(input);
var app = parser.ParseConfigApplication();
var exception = Assert.Throws <TyeYamlException>(() => app.Validate());
Assert.Contains(CoreStrings.FormatMultipleBindingWithoutName("ingress"), exception.Message);
}
public void DefineTransform()
{
const string yaml = @"
- define: standard-transform
value:
- [ translate, 1, -1, 1 ]
- [ scale, 0.5, 0.5, 0.5 ]";
var parser = new YamlParser();
parser.LoadYaml(yaml);
var transform = parser.Transforms["STANDARD-TRANSFORM"];
var expected = Matrix4x4.Scaling(0.5f, 0.5f, 0.5f)
* Matrix4x4.Translation(1, -1, 1);
Assert.Equal(expected, transform);
}
public void Parse_WithOneSphere_ShouldCreateASphere()
{
string yamlString = @"shapes:
- type: sphere
transform:
scale: [ 1.0, 1.0, 1.0 ]
translate: [ 0.0, 0.0, 0.0 ]
material:
color: [ 0.8, 0.5, 0.3 ]
shininess: 50";
YamlParser yamlParser = new YamlParser(yamlString);
List <Shape> shapes = yamlParser.ParseShapes();
Assert.Single(shapes);
Assert.True(shapes[0] is Sphere);
Assert.Equal(new Color(0.8, 0.5, 0.3), shapes[0].Material.Color);
}
public void Parse_WithMultipleLights_ShouldCreateTwoLights()
{
string yamlString = @"lights:
- type: point
position: [-4.9, 4.9, -1]
color: [1, 1, 1]
- type: point
position: [0, 0, 0]
color: [0.5, 0.5, 0.5]";
YamlParser yamlParser = new YamlParser(yamlString);
List <ILight> lights = yamlParser.ParseLights();
Assert.Equal(2, lights.Count);
Assert.Equal(new Color(1, 1, 1), lights[0].Color);
Assert.Equal(new Color(0.5, 0.5, 0.5), lights[1].Color);
}
public void Parse_WithSingleLight_ShouldCreateSingleLight()
{
string yamlString = @"lights:
- type: point
position: [-4.9, 4.9, -1]
color: [1, 1, 1]";
const double epsilon = 0.0001;
IEqualityComparer <Point> PointComparer =
Point.GetEqualityComparer(epsilon);
YamlParser yamlParser = new YamlParser(yamlString);
List <ILight> lights = yamlParser.ParseLights();
Assert.Single(lights);
Assert.Equal(new Color(1, 1, 1), lights[0].Color);
Assert.Equal(new Point(-4.9, 4.9, -1), ((PointLight)lights[0]).Position, PointComparer);
}
/// <summary>
/// Gets a value from the session info YAML. Returns true if successfull, false if there is an error.
/// </summary>
/// <param name="query">The YAML query path to the value.</param>
/// <param name="value">When this method returns, contains the requested value if the query was valid, or null if the query was invalid.</param>
public bool TryGetValue(string query, out string value)
{
if (!this.IsValidYaml)
{
value = null;
return(false);
}
try
{
value = YamlParser.Parse(_yaml, query);
return(true);
}
catch (Exception)
{
value = null;
return(false);
}
}
public void Services_Tags_SetCorrectly()
{
var input = @"
services:
- name: ingress
tags:
- tagA
- with space
- ""C.X""
";
using var parser = new YamlParser(input);
var actual = parser.ParseConfigApplication();
var expected = _deserializer.Deserialize <ConfigApplication>(new StringReader(input));
TyeAssert.Equal(expected, actual);
}
public void ParseStaticSessionInfo(string sessionInfo, bool isPlayerCar)
{
this.TeamId = Parser.ParseInt(ParseDriverYaml(sessionInfo, "TeamID"));
this.TeamName = ParseDriverYaml(sessionInfo, "TeamName");
this.Car.CarId = Parser.ParseInt(ParseDriverYaml(sessionInfo, "CarID"));
this.Car.CarNumber = ParseDriverYaml(sessionInfo, "CarNumberRaw");
this.Car.CarClassId = Parser.ParseInt(ParseDriverYaml(sessionInfo, "CarClassID"));
this.Car.CarClassRelSpeed = Parser.ParseInt(ParseDriverYaml(sessionInfo, "CarClassRelSpeed"));
if (isPlayerCar)
{
this.Car.DriverCarFuelMaxLtr = Parser.ParseFloat(YamlParser.Parse(sessionInfo, "DriverInfo:DriverCarFuelMaxLtr:"), -1.0f);
this.Car.DriverCarMaxFuelPct = Parser.ParseFloat(YamlParser.Parse(sessionInfo, "DriverInfo:DriverCarMaxFuelPct:"), -1.0f);
this.Car.DriverPitTrkPct = Parser.ParseFloat(YamlParser.Parse(sessionInfo, "DriverInfo:DriverPitTrkPct:"), -1.0f);
}
bool isPaceCar = Parser.ParseInt(ParseDriverYaml(sessionInfo, "CarIsPaceCar")) == 1;
this.IsPaceCar = this.CustId == -1 || isPaceCar;
}
private void GetQualyResults(string sessionInfo)
{
// TODO: stop if qualy is finished
for (int position = 0; position < _drivers.Count; position++)
{
string idValue = "0";
if (!YamlParser.TryGetValue(sessionInfo, string.Format("QualifyResultsInfo:Results:Position:{{{0}}}CarIdx:", position), out idValue))
{
continue;
}
// Find driver and update results
int id = int.Parse(idValue);
var driver = _drivers.SingleOrDefault(d => d.Id == id);
if (driver != null && !driver.IsPaceCar)
{
driver.CurrentResults.QualifyingPosition = position + 1;
}
}
}
public void BlockValueTest()
{
MemoryStream stream = new MemoryStream();
StreamWriter writer = new StreamWriter(stream);
writer.WriteLine("comments:");
writer.WriteLine(" Late afternoon is best.");
writer.WriteLine(" Backup contact is Nancy");
writer.WriteLine(" Billsmer @ 338-4338.");
writer.Flush();
stream.Seek(0, SeekOrigin.Begin);
using (TextReader reader = new StreamReader(stream))
{
YamlParser parser = new YamlParser(reader, null);
Assert.IsTrue(parser.TryParse());
}
}
public void MultipleServicesBindingsMustUniqueNames()
{
var input = @"
services:
- name: app
bindings:
- port: 8080
protocol: http
name: a
- port: 8080
protocol: http
name: a";
using var parser = new YamlParser(input);
var app = parser.ParseConfigApplication();
var exception = Assert.Throws <TyeYamlException>(() => app.Validate());
Assert.Contains(CoreStrings.FormatMultipleBindingWithSameName("service"), exception.Message);
}
private static RogueskivAppConfig GetRogueskivAppConfig()
{
var dataFilePath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
APP_DATA_FOLDER
);
CheckApplicationDataFolder(dataFilePath);
var rogueskivConfig = YamlParser.ParseFile <RogueskivAppConfig>(dataFilePath, CONFIG_FILE_NAME);
rogueskivConfig.GlobalConfigFilePath = Path.Combine(dataFilePath, $"{CONFIG_FILE_NAME}.yaml");
rogueskivConfig.GameStatsFilePath = Path.Combine(dataFilePath, $"{GAME_STATS_FILE_NAME}.yaml");
rogueskivConfig.GameModeFilesPath = Path.Combine(dataFilePath, GAME_MODE_FILES_PATH);
rogueskivConfig.GameModes = GetGameModes(rogueskivConfig);
rogueskivConfig.CheckGameModeIndexBounds();
return(rogueskivConfig);
}
public void DetectYamlTest()
{
var input = @"
---
title: About
---
Lorem ipsum";
var converter = new StringToStreamConverter(input);
var typeDetector = new TypeDetector(new StreamReader(converter.GetStreamFromString()));
using TextReader sr = new StringReader(input);
var parser = new YamlParser <SinglePage>(sr, string.Empty);
var single = parser.GetAsSinglePage();
Assert.Equal(FrontMatterType.Yaml, typeDetector.GetFrontMatterType());
Assert.Equal("About", single.Title);
Assert.Equal("Lorem ipsum", single.Content);
}
public void TestYamlNewElement()
{
string yaml = @"
- add: camera
";
var yml = new YamlParser();
yml.ParseYaml(yaml);
var root = yml.Root;
Assert.IsFalse(root.IsEmpty);
Assert.IsTrue(root.HasList);
root = root.List[0];
Assert.AreEqual(root.Key, "add");
Assert.AreEqual(root.String, "camera");
}
private static SceneBuilder ParseYamlFile(CommandLine cl)
{
string file = cl.Input;
var parser = new YamlParser();
if (parser.Parse(file))
{
Console.WriteLine("Parsed!");
return(new SceneBuilder(parser.Root));
}
else
{
Console.WriteLine("Oh no!");
}
return(null);
}
private void ProcessFile(Object state)
{
var logger = ServiceLocator.Current.GetInstance <ILogger>();
var file = state as String;
if (!String.IsNullOrEmpty(file) && File.Exists(file))
{
Stopwatch startTime = Stopwatch.StartNew();
while (true)
{
if (IsFileAccessible(file))
{
try
{
var yaml = YamlParser.Load(file).Documents;
foreach (var document in yaml)
{
AddNode(document.Root, String.Empty);
}
break;
}
catch (Exception e)
{
logger.ErrorFormat("Some erro was occured during \"{0}\" processing ({1}).", file, e.Message);
}
}
// Calculate the elapsed time and stop if the maximum retry
// period has been reached.
TimeSpan timeElapsed = startTime.Elapsed;
if (timeElapsed > maximumRetryPeriod)
{
logger.ErrorFormat("The file \"{0}\" could not be processed.", file);
break;
}
Thread.Sleep(retryDelay);
}
}
}
public void TestParse(string fileNme)
{
//DeviceDetectorSettings.RegexesDirectory = @"D:\WorkSpaces\GitHubVisualStudio\DeviceDetector.Net\src\DeviceDetector.NET\";
var parser = new YamlParser <List <DeviceDetectorFixture> >();
var _fixtureData = parser.ParseFile($"{Utils.CurrentDirectory()}\\fixtures\\{fileNme}.yml");
foreach (var expected in _fixtureData)
{
var dd = DeviceDetector.GetInfoFromUserAgent(expected.user_agent);
dd.Success.Should().BeTrue();
dd.Match.OsFamily.Should().BeEquivalentTo(expected.os_family);
dd.Match.BrowserFamily.Should().BeEquivalentTo(expected.browser_family);
if (expected.os != null)
{
if (expected.os is Dictionary <object, object> dicOs && dicOs.Count > 0)
{
var osName = dicOs["name"];
dd.Match.Os.Name.Should().BeEquivalentTo(osName.ToString());
}
else
{
if (expected.os is List <object> listOs && listOs.Count > 0)
{
throw new Exception();
//var osName = dicOs["name"];
//dd.Match.Os.Name.Should().BeEquivalentTo(osName.ToString());
}
}
}
if (expected.client != null)
{
dd.Match.Client.Type.Should().BeEquivalentTo(expected.client.type);
dd.Match.Client.Name.Should().BeEquivalentTo(expected.client.name);
}
if (expected.device != null)
{
dd.Match.DeviceType?.Should().BeEquivalentTo(expected.device.type);
dd.Match.DeviceBrand?.Should().BeEquivalentTo((expected.device.brand ?? ""));
dd.Match.DeviceModel?.Should().BeEquivalentTo((expected.device.model ?? ""));
}
}
/// <summary>
/// Deserialize C# object(s) from a YAML text. Since a YAML text can contain multiple YAML documents, each of which
/// represents a C# object, the result is returned as an array of <see cref="object"/>.
/// </summary>
/// <param name="yaml">A YAML text from which C# objects are deserialized.</param>
/// <param name="types">Expected type(s) of the root object(s) in the YAML stream.</param>
/// <returns>C# object(s) deserialized from YAML text.</returns>
public object[] Deserialize(string yaml, params Type[] types)
{
var c = config != null ? config : YamlNode.DefaultConfig;
var parser = new YamlParser();
var nodes = parser.Parse(yaml, c);
var objects = new List<object>();
for ( int i = 0; i < nodes.Count; i++ ) {
var node = nodes[i];
if ( i < types.Length ) {
objects.Add(constructor.NodeToObject(node, types[i], c));
} else {
objects.Add(constructor.NodeToObject(node, null, c));
}
}
return objects.ToArray();
}
static YamlNode()
{
// Initializing order matters !
DefaultTagPrefix = "tag:yaml.org,2002:";
DefaultConfig = new YamlConfig();
DefaultParser = new YamlParser();
DefaultPresenter = new YamlPresenter();
DefaultSerializerContext = new SerializerContext(DefaultConfig);
foreach (var shortToLongTag in ShortToLongTags)
{
LongToShortTags.Add(shortToLongTag.Value, shortToLongTag.Key);
}
}
/// <summary>
/// Deserialize C# object(s) from a YAML text. Since a YAML text can contain multiple YAML documents, each of which
/// represents a C# object, the result is returned as an array of <see cref="object"/>.
/// </summary>
/// <param name="yaml">A YAML text from which C# objects are deserialized.</param>
/// <param name="types">Expected type(s) of the root object(s) in the YAML stream.</param>
/// <returns>C# object(s) deserialized from YAML text.</returns>
public object[] Deserialize(string yaml, params Type[] types)
{
var context = config.CreateContext();
var parser = new YamlParser();
var nodes = parser.Parse(yaml, config);
var objects = new List<object>();
for ( int i = 0; i < nodes.Count; i++ ) {
var node = nodes[i];
objects.Add(Constructor.NodeToObject(node, i < types.Length ? types[i] : null, context));
}
return objects.ToArray();
}
static YamlNode()
{
// Initializing order matters !
DefaultTagPrefix = "tag:yaml.org,2002:";
DefaultConfig = new YamlConfig();
DefaultParser = new YamlParser();
DefaultPresenter = new YamlPresenter();
}
