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 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 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 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 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 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 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 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); }
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 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 PascalCSharp() { //arrange string text = TransformationComponentUnitTest.Resource1.CSharpPascalRules; var component = new TransformationComponent(); //act var actual = component.TransformToRules(text); }
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 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 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 }); }
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 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 }); }