public void ToRulesTypeStr() { //arrange var name = "a"; var bnf = "a/child"; var rules = "Some strange comment-like text\n" + "with some new lines and //////star\n" + "but eventually /start\n" + "/type " + name + " ::= " + bnf + "\n" + "/end\n" + "Some more comments"; var component = new TransformationComponent(); //act var actual = component.TransformToRules(rules); //assert Assert.AreEqual(actual.Languages.Count, 0); var resultRules = actual.GetBaseRules; Assert.AreEqual(1, resultRules.Count); Assert.IsTrue(resultRules.ContainsKey(name)); var resultTypeRule = resultRules[name] as TypeRule; var basicBNFRule = new BasicBNFRule { new BNFString("a"), new BNFSystemRef(new Child()) }; TestUtil.AssertBNF(resultTypeRule, name, basicBNFRule); }
public void ToRulesEmptyType() { //arrange var name = "a"; var rules = "Some strange comment-like text\n" + "with some new lines and //////star\n" + "but eventually /start\n" + "/type " + name + "\n" + "/end\n" + "Some more comments"; var component = new TransformationComponent(); //act var actual = component.TransformToRules(rules); //assert Assert.AreEqual(actual.Languages.Count, 0); var resultRules = actual.GetBaseRules; Assert.AreEqual(1, resultRules.Count); Assert.IsTrue(resultRules.ContainsKey(name)); var resultTypeRule = resultRules[name] as TypeRule; TestUtil.AssertBNF(resultTypeRule, name); }
public void ToRulesBNFFakeSys() { //arrange var name = "a"; var fakeName = "adkjlxfkbn"; var rules = "Some strange comment-like text\n" + "with some new lines and //////star\n" + "but eventually /start\n" + name + " ::= /" + fakeName + "\n" + "/end\n" + "Some more comments"; var component = new TransformationComponent(); //act try { var actual = component.TransformToRules(rules); }//assert catch (TransformComponentException tr) { Assert.IsInstanceOfType(tr, typeof(RuleParseException)); Assert.IsInstanceOfType(tr.InnerException, typeof(BaseRuleParseException)); Assert.IsInstanceOfType(tr.InnerException.InnerException, typeof(SyntaxErrorPlaced)); } }
public void RequireBNFRealisation() { //Arrange var rules = "/start\n" + "a\n" + "/language_start a\n" + "/language_end\n" + "/end\n"; var component = new TransformationComponent(); //Act try { var result = component.TransformToRules(rules); } catch (RuleParseException ex) { Assert.IsInstanceOfType(ex.InnerException, typeof(LangRuleParseException)); Assert.IsInstanceOfType(ex.InnerException.InnerException, typeof(SyntaxErrorPlaced)); Assert.IsInstanceOfType(ex.InnerException.InnerException.InnerException, typeof(EOSException)); return; } //Assert Assert.Fail(); }
public void ToRulesBNF() { //arrange var name = "a"; var str = "a"; var rules = "Some strange comment-like text\n" + "with some new lines and //////star\n" + "but eventually /start\n" + name + " ::= " + str + "\n" + "/end\n" + "Some more comments"; var component = new TransformationComponent(); //act var actual = component.TransformToRules(rules); //assert Assert.AreEqual(actual.Languages.Count, 0); var resultRules = actual.GetBaseRules; Assert.AreEqual(1, resultRules.Count); Assert.IsTrue(resultRules.ContainsKey(name)); var resultBNFRule = resultRules[name] as BNFRule; var expBasicBNF = new BasicBNFRule(); expBasicBNF.Add(new BNFString(str)); TestUtil.AssertBNF(resultBNFRule, name, expBasicBNF); }
public void SimpleRBnf() { //arrange var name = "r"; var pattern = "a|<r>"; var rules = "/start\n" + name + " ::= " + pattern + "\n" + "/translate_rules_start\n" + name + " ::= a\n" + "/translate_rules_end\n" + "/end"; var component = new TransformationComponent(); //act var result = component.TransformToRules(rules); //assert result.GetBaseRules.ContainsKey(name); result.GetBaseRules.ContainsKey("T+" + name); TestUtil.AssertBNF(result.GetBaseRules[name] as BNFRule, name, new BasicBNFRule { new BNFString("a") }, new BasicBNFRule { new BNFReference("r") }); TestUtil.AssertBNF(result.GetBaseRules["T+" + name] as BNFRule, "T+" + name, new BasicBNFRule { new BNFString("a") }); }
public void ToRulesTwoReg() { //arrange var pattern = "[1-9][0-9]*|0"; var name = "a"; var pattern2 = @"\w+"; var name2 = "b"; var rules = "Some strange comment-like text\n" + "with some new lines and //////star\n" + "but eventually /start\n" + "/reg " + name + " ::= " + pattern + "\n" + "/reg " + name2 + " ::= " + pattern2 + "\n" + "/end\n" + "Some more comments"; var component = new TransformationComponent(); //act var actual = component.TransformToRules(rules); //assert Assert.AreEqual(actual.Languages.Count, 0); var resultRules = actual.GetBaseRules; Assert.AreEqual(resultRules.Count, 2); Assert.IsTrue(resultRules.ContainsKey(name)); var resultRegRule = resultRules[name] as RegexRule; TestUtil.AssertReg(resultRegRule, name, pattern); resultRegRule = resultRules[name2] as RegexRule; TestUtil.AssertReg(resultRegRule, name2, pattern2); }
private void UpdateNode(ref ModelNodeTransformation node) { // Compute LocalMatrix if ((node.Flags & ModelNodeFlags.EnableTransform) == ModelNodeFlags.EnableTransform) { TransformationComponent.CreateMatrixTRS(ref node.Transform.Translation, ref node.Transform.Rotation, ref node.Transform.Scaling, out node.LocalMatrix); } var nodeTransformationsLocal = this.nodeTransformations; var parentIndex = node.ParentIndex; // Update Enabled bool renderingEnabledRecursive = (node.Flags & ModelNodeFlags.EnableRender) == ModelNodeFlags.EnableRender; if (parentIndex != -1) { renderingEnabledRecursive &= nodeTransformationsLocal[parentIndex].RenderingEnabledRecursive; } node.RenderingEnabledRecursive = renderingEnabledRecursive; if (renderingEnabledRecursive) { // Compute WorldMatrix if (parentIndex != -1) { Matrix.Multiply(ref node.LocalMatrix, ref nodeTransformationsLocal[parentIndex].WorldMatrix, out node.WorldMatrix); } else { node.WorldMatrix = node.LocalMatrix; } } }
public void ToRulesTwoBNFSameName() { //arrange var name = "a"; var name2 = name; var rules = "Some strange comment-like text\n" + "with some new lines and //////star\n" + "but eventually /start\n" + name + " ::= a\n" + name2 + " ::= b\n" + "/end\n" + "Some more comments"; var component = new TransformationComponent(); //act try { var actual = component.TransformToRules(rules); } catch (System.Exception e) { //assert Assert.IsInstanceOfType(e, typeof(RuleParseException)); Assert.IsInstanceOfType(e.InnerException, typeof(BaseRuleParseException)); Assert.IsInstanceOfType(e.InnerException.InnerException, typeof(SyntaxErrorPlaced)); Assert.IsInstanceOfType(e.InnerException.InnerException.InnerException, typeof(ConstructAlreadyDefined)); } }
public void RequireReg() { //Arrange var rules = "/start\n" + "/reg b ::= [0-9]\n" + "a\n" + "/language_start a\n" + "a ::= abc\n" + "/language_end\n" + "/end\n"; var component = new TransformationComponent(); //Act try { var result = component.TransformToRules(rules); } catch (RuleParseException ex) { Assert.IsInstanceOfType(ex.InnerException, typeof(LangRuleParseException)); Assert.IsInstanceOfType(ex.InnerException.InnerException, typeof(SyntaxErrorPlaced)); Assert.IsInstanceOfType(ex.InnerException.InnerException.InnerException, typeof(TranslateRuleRequired)); return; } //Assert Assert.Fail("expected fail"); }
public void TransformNoTargetLanguage() { //arrange string text = "Some text"; AllRules allRules = new AllRules(); allRules.AddBaseRules(new System.Collections.Generic.Dictionary <string, Rule>()); string sourceLang = "a"; string targetLang = "b"; allRules.AddLanguageRules(sourceLang, new System.Collections.Generic.Dictionary <string, Rule>()); TransformationComponent transformationComponent = new TransformationComponent(); //act try { transformationComponent.Transform(text, allRules, sourceLang, targetLang); } catch (TransformComponentException tr) { Assert.IsInstanceOfType(tr, typeof(ModelParseException)); Assert.IsInstanceOfType(tr.InnerException, typeof(NoLanguageRulesFound)); } }
/// <summary> /// Create a new <see cref="Entity"/> instance having the provided name and initial position. /// </summary> /// <param name="position">The initial position of the entity</param> /// <param name="name">The name to give to the entity</param> public Entity(Vector3 position, string name = null) : base(name) { Tags.PropertyUpdated += EntityPropertyUpdated; Transformation = new TransformationComponent(); transformation.Translation = position; }
public void ToRulesTypeOneParam() { //arrange var n1 = "c"; var name = "a"; var param_name = "b"; var param_body = "<" + n1 + ">"; var bnf = "<" + param_name + ">/child"; var rules = "Some strange comment-like text\n" + "with some new lines and //////star\n" + "but eventually /start\n" + n1 + "\n" + "/type " + name + " ::= " + bnf + "\n" + "/params_start\n" + param_name + " ::= " + param_body + "\n" + "/params_end\n" + "/end\n" + "Some more comments"; var component = new TransformationComponent(); //act var actual = component.TransformToRules(rules); //assert Assert.AreEqual(actual.Languages.Count, 0); var resultRules = actual.GetBaseRules; Assert.AreEqual(3, resultRules.Count); CollectionAssert.Contains(resultRules.Keys, n1); TestUtil.AssertBNF((BNFRule)resultRules[n1], n1, new BasicBNFRule[0]); Assert.IsTrue(resultRules.ContainsKey(name)); var resultTypeRule = resultRules[name] as TypeRule; var basicBNFRule = new BasicBNFRule(); basicBNFRule.Add(new BNFReference("a.b")); basicBNFRule.Add(new BNFSystemRef(new Child())); TestUtil.AssertBNF(resultTypeRule, name, new BasicBNFRule[] { basicBNFRule }); var full_par_n = name + "." + param_name; var resultBNFRule = resultRules[full_par_n] as BNFRule; basicBNFRule = new BasicBNFRule(); basicBNFRule.Add(new BNFReference(n1)); TestUtil.AssertBNF(resultBNFRule, full_par_n, new BasicBNFRule[] { basicBNFRule }); }
public void PascalCSharp() { //arrange string text = TransformationComponentUnitTest.Resource1.CSharpPascalRules; var component = new TransformationComponent(); //act var actual = component.TransformToRules(text); }
public void PascalToCSharp() { //arrange var rules = TransformationComponentUnitTest.Resource1.CSharpPascalRules; var source = TransformationComponentUnitTest.Resource1.PascalSource; var component = new TransformationComponent(); //act var actual = component.Transform(source, rules, "Pascal", "CSharp"); System.Diagnostics.Debug.WriteLine(actual); }
public void TransformRulesTypeTypeTypeEx() { //arrange var reg = "r"; var pattern = "[0-9]"; var typename = "a"; var typep = "<" + reg + ">"; var typebnf = typep + "/child"; var exname = "b"; var exname2 = "c"; var exbnf = "b/child"; var exbnf2 = "<r>/child"; var rules_txt = "/start\n" + "/reg " + reg + " ::= " + pattern + "\n" + "/type " + typename + " ::= " + typebnf + "\n" + "/type= " + typename + " /type " + exname + " ::= " + exbnf + '\n' + "/type= " + exname + " /type " + exname2 + " ::= " + exbnf2 + '\n' + "/end"; var component = new TransformationComponent(); //act var actual = component.TransformToRules(rules_txt); //assert Assert.AreEqual(0, actual.Languages.Count); var resultRules = actual.GetBaseRules; Assert.AreEqual(4, resultRules.Count); CollectionAssert.Contains(resultRules.Keys, typename); CollectionAssert.Contains(resultRules.Keys, exname); var bnfrule = resultRules[exname] as BNFRule; Assert.IsNotNull(bnfrule); var basicBNFRule = new BasicBNFRule { new BNFReference("r"), new BNFString("b"), new BNFSystemRef(new Child()) }; TestUtil.AssertBNF(bnfrule, exname, basicBNFRule); var expected = component.TransformToRules("/start\n" + "/reg r ::= [0-9]\n" + "/type b ::= <r>b/child\n" + "/end").GetBaseRules["b"] as TypeRule; Assert.IsTrue(expected.Equals(resultRules["b"] as TypeRule)); }
public void TransformRulesTypeWithParamTypeEx() { //arrange var reg = "r"; var pattern = "[0-9]"; var typename = "a"; var typename2 = "b"; var paramname = "c"; var typep = "<" + paramname + ">"; var typebnf = "<" + paramname + ">" + "/child"; var typebnf2 = "a/child"; var param_txt = "<" + reg + ">"; var rules_txt = "/start\n" + "/reg " + reg + " ::= " + pattern + "\n" + "/type " + typename + " ::= " + typebnf + "\n" + "/params_start\n" + paramname + " ::= " + param_txt + "\n" + "/params_end\n" + "/type= " + typename + " /type " + typename2 + " ::= " + typebnf2 + "\n" + "/end"; var component = new TransformationComponent(); //act var actual = component.TransformToRules(rules_txt); //assert Assert.AreEqual(0, actual.Languages.Count); var resultRules = actual.GetBaseRules; Assert.AreEqual(4, resultRules.Count); CollectionAssert.Contains(resultRules.Keys, typename); CollectionAssert.Contains(resultRules.Keys, reg); CollectionAssert.Contains(resultRules.Keys, typename2); CollectionAssert.Contains(resultRules.Keys, typename + "." + paramname); var bnfrule = resultRules[typename2] as BNFRule; Assert.IsNotNull(bnfrule); var basicBNFRule = new BasicBNFRule { new BNFReference("a.c"), new BNFString("a"), new BNFSystemRef(new Child()) }; TestUtil.AssertBNF(bnfrule, typename2, basicBNFRule); }
public void ToRulesEmptyBodyClean() { //arrange var rules = "/start\n" + "/end\n"; var component = new TransformationComponent(); //act var actual = component.TransformToRules(rules); //assert Assert.AreEqual(actual.Languages.Count, 0); Assert.AreEqual(actual.GetBaseRules.Count, 0); }
public void ToRulesBNFRefReg() { //arrange var name = "a"; var name2 = "b"; var pattern = "[0-9]+"; var rules = "Some strange comment-like text\n" + "with some new lines and //////star\n" + "but eventually /start\n" + "/reg " + name + " ::= " + pattern + "\n" + name2 + " ::= <" + name + ">\n" + "/end\n" + "Some more comments"; var component = new TransformationComponent(); //act var actual = component.TransformToRules(rules); //assert Assert.AreEqual(actual.Languages.Count, 0); var resultRules = actual.GetBaseRules; Assert.AreEqual(2, resultRules.Count); Assert.IsTrue(resultRules.ContainsKey(name)); var resultRegRule = resultRules[name] as RegexRule; TestUtil.AssertReg(resultRegRule, name, pattern); Assert.IsTrue(resultRules.ContainsKey(name2)); var resultBNFRule = resultRules[name2] as BNFRule; var expBasicBNF = new BasicBNFRule { new BNFReference(name) }; TestUtil.AssertBNF(resultBNFRule, name2, new BasicBNFRule[1] { expBasicBNF }); }
/// <summary> /// Updades the graphics transformation from the given physics transformation /// </summary> /// <param name="physicsTransform"></param> internal void UpdateTransformationComponent(Matrix physicsTransform) { var entity = (Entity)Collider.EntityObject; if (Shape.Shape.LocalOffset != Vector3.Zero || Shape.Shape.LocalRotation != Quaternion.Identity) { physicsTransform = Matrix.Multiply(Shape.Shape.NegativeCenterMatrix, physicsTransform); } var rotation = Quaternion.RotationMatrix(physicsTransform); var translation = physicsTransform.TranslationVector; //Invert up axis in the case of a Sprite if (Sprite) { translation.Y = -translation.Y; } if (entity.Transformation.UseTRS) { entity.Transformation.Translation = translation; entity.Transformation.Rotation = rotation; } else { var worldMatrix = entity.Transformation.WorldMatrix; Vector3 scale; scale.X = (float)Math.Sqrt((worldMatrix.M11 * worldMatrix.M11) + (worldMatrix.M12 * worldMatrix.M12) + (worldMatrix.M13 * worldMatrix.M13)); scale.Y = (float)Math.Sqrt((worldMatrix.M21 * worldMatrix.M21) + (worldMatrix.M22 * worldMatrix.M22) + (worldMatrix.M23 * worldMatrix.M23)); scale.Z = (float)Math.Sqrt((worldMatrix.M31 * worldMatrix.M31) + (worldMatrix.M32 * worldMatrix.M32) + (worldMatrix.M33 * worldMatrix.M33)); TransformationComponent.CreateMatrixTRS(ref translation, ref rotation, ref scale, out entity.Transformation.WorldMatrix); if (entity.Transformation.Parent == null) { entity.Transformation.LocalMatrix = entity.Transformation.WorldMatrix; } else { //We are not root so we need to derive the local matrix as well var inverseParent = entity.Transformation.Parent.WorldMatrix; inverseParent.Invert(); entity.Transformation.LocalMatrix = Matrix.Multiply(entity.Transformation.WorldMatrix, inverseParent); } } }
public void ToRulesEmptyBody() { //arrange var rules = "Some strange comment-like text\n" + "with some new lines and //////star\n" + "but eventually /start\n" + "/end\n" + "Some more comments"; var component = new TransformationComponent(); //act var actual = component.TransformToRules(rules); //assert Assert.AreEqual(actual.Languages.Count, 0); Assert.AreEqual(actual.GetBaseRules.Count, 0); }
public void SimpleTenLanguages() { //Arrange var rules = "/start\n" + "a\n" + "/language_start a\n" + "a ::= a\n" + "/language_end\n" + "/language_start b\n" + "a ::= a\n" + "/language_end\n" + "/language_start c\n" + "a ::= a\n" + "/language_end\n" + "/language_start d\n" + "a ::= a\n" + "/language_end\n" + "/language_start e\n" + "a ::= a\n" + "/language_end\n" + "/language_start f\n" + "a ::= a\n" + "/language_end\n" + "/language_start g\n" + "a ::= a\n" + "/language_end\n" + "/language_start h\n" + "a ::= a\n" + "/language_end\n" + "/language_start i\n" + "a ::= a\n" + "/language_end\n" + "/language_start j\n" + "a ::= a\n" + "/language_end\n" + "/end\n"; var component = new TransformationComponent(); //Act var result = component.TransformToRules(rules); //Assert Assert.AreEqual(10, result.Languages.Count); }
public void SimpleOneLanguage() { //Arrange var rules = "/start\n" + "a\n" + "/language_start a\n" + "a ::= a\n" + "/language_end\n" + "/end\n"; var component = new TransformationComponent(); //Act var result = component.TransformToRules(rules); //Assert Assert.AreEqual(1, result.Languages.Count); }
public void TransformRulesSimpleTypeEx() { //arrange var typename = "a"; var typep = "a"; var typebnf = typep + "/child"; var exname = "b"; var exbnf = "b"; var rules_txt = "/start\n" + "/type " + typename + " ::= " + typebnf + "\n" + "/type= " + typename + " " + exname + " ::= " + exbnf + '\n' + "/end"; var component = new TransformationComponent(); //act var actual = component.TransformToRules(rules_txt); //assert Assert.AreEqual(0, actual.Languages.Count); var resultRules = actual.GetBaseRules; Assert.AreEqual(2, resultRules.Count); CollectionAssert.Contains(resultRules.Keys, typename); CollectionAssert.Contains(resultRules.Keys, exname); var bnfrule = resultRules[exname] as BNFRule; Assert.IsNotNull(bnfrule); var basicBNFRule = new BasicBNFRule { new BNFString(typep + exbnf) }; TestUtil.AssertBNF(bnfrule, exname, basicBNFRule); var expected = component.TransformToRules("/start\n" + "b ::= ab\n" + "/end").GetBaseRules["b"] as BNFRule; Assert.IsTrue(expected.Equals(resultRules["b"] as BNFRule)); }
public void SimpleTransform() { //arrange var text = "a"; var sourceLang = "a"; var targetLang = "b"; AllRules allRules = new AllRules(); allRules.AddBaseRules( new System.Collections.Generic.Dictionary <string, Rule> { ["Program"] = new BNFRule("Program") } ); allRules.AddLanguageRules(sourceLang, new System.Collections.Generic.Dictionary <string, Rule> { ["Program"] = new BNFRule("Program") { new BasicBNFRule { new BNFString("a") } } }); allRules.AddLanguageRules(targetLang, new System.Collections.Generic.Dictionary <string, Rule> { ["Program"] = new BNFRule("Program") { new BasicBNFRule { new BNFString("b") } } }); var transformationComponent = new TransformationComponent(); var expected = "b"; //act var actual = transformationComponent.Transform(text, allRules, sourceLang, targetLang); //assert Assert.AreEqual(expected, actual); }
public void AddComponent <T>(T component) where T : GameObjectComponent { component.GameObject = this; if (this.GetComponent <T>() != null) { this.RemoveComponent <T>(); } _components.Add(component.GetType(), component); if (component.GetType() == typeof(TransformationComponent)) { this.Transform = component as TransformationComponent; } if (_isLoaded) { // We are already loaded to load this component component.Loaded(); } }
public void ToRulesEmpty() { //arrange var rules = string.Empty; var component = new TransformationComponent(); //act try { var actual = component.TransformToRules(rules); } catch (System.Exception e) { //assert Assert.IsInstanceOfType(e, typeof(RuleParseException)); Assert.IsInstanceOfType(e.InnerException, typeof(InputIsEmpty)); } }
public void ToRulesNoStart() { //arrange var rules = "Some strange comment-like text\n" + "with some new lines and //////star"; var component = new TransformationComponent(); //act try { var actual = component.TransformToRules(rules); } catch (System.Exception e) { //assert Assert.IsInstanceOfType(e, typeof(RuleParseException)); Assert.IsInstanceOfType(e.InnerException, typeof(NoStartDetected)); } }
public void ToRulesSysPresentation(System.Type type) { //arrange var name = "a"; var rule = (SystemRule)System.Activator.CreateInstance(type); var str = rule.Literal; var rules = "Some strange comment-like text\n" + "with some new lines and //////star\n" + "but eventually /start\n" + name + " ::= " + str + "\n" + "/end\n" + "Some more comments"; var component = new TransformationComponent(); //act var actual = component.TransformToRules(rules); //assert Assert.AreEqual(actual.Languages.Count, 0); var resultRules = actual.GetBaseRules; Assert.AreEqual(1, resultRules.Count); Assert.IsTrue(resultRules.ContainsKey(name)); var resultBNFRule = resultRules[name] as BNFRule; var expBasicBNF = new BasicBNFRule { new BNFSystemRef(rule) }; TestUtil.AssertBNF(resultBNFRule, name, new BasicBNFRule[1] { expBasicBNF }); }
public void HasTwoLang_BNF() { //arrange var rules = "/start\n" + "Program\n" + "/language_start a\n" + "Program ::= a\n" + "/language_end\n" + "/language_start b\n" + "Program ::= b\n" + "/language_end\n" + "/end"; var text = "a"; var component = new TransformationComponent(); var expected = "b"; //act var actual = component.Transform(text, rules, "a", "b"); //assert Assert.IsNotNull(actual); Assert.AreEqual(expected, actual); }