public void Modify()
{
var segment1 = new Segment("segment1", false);
var segment2 = new Segment("segment2", false);
ICollection <Segment> set = SegmentSet.New(new Segment[] { segment1 });
Assert.That(set.IsReadOnly, Is.EqualTo(true));
try
{
set.Add(segment2);
Assert.Fail("Add should have thrown an exception.");
}
catch (NotSupportedException)
{
}
try
{
set.Remove(segment1);
Assert.Fail("Remove should have thrown an exception.");
}
catch (NotSupportedException)
{
}
}
private static Dictionary <string, SegmentSpecification> Get5010Spec()
{
lock (syncObject)
if (_5010Specification == null)
{
Stream specStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("EdiFactory.Specifications.Ansi-5010Specification.xml");
StreamReader reader = new StreamReader(specStream);
SegmentSet set = SegmentSet.Deserialize(reader.ReadToEnd());
_5010Specification = new Dictionary <string, SegmentSpecification>();
foreach (var segment in set.Segments)
{
foreach (var element in segment.Elements)
{
if (element.Type == ElementDataTypeEnum.Identifier && !string.IsNullOrEmpty(element.QualifierSetRef))
{
var qualifierSet = set.QualifierSets.FirstOrDefault(qs => qs.Name == element.QualifierSetRef);
if (qualifierSet != null)
{
element.AllowedIdentifiers.AddRange(qualifierSet.AllowedIdentifiers);
element.QualifierSetId = qualifierSet.Id;
}
}
}
_5010Specification.Add(segment.SegmentId, segment);
}
}
return(_5010Specification);
}
public void TrySubtractLookahead()
{
var set1 = ParseItemSet.New(new ParseItem[] { _item10, _item11, _item20 });
var laA = SegmentSet.New(new Segment[] { _lookaheadA });
var laB = SegmentSet.New(new Segment[] { _lookaheadB });
var laC = SegmentSet.New(new Segment[] { _lookaheadC });
var laAB = SegmentSet.New(new Segment[] { _lookaheadA, _lookaheadB });
var laBC = SegmentSet.New(new Segment[] { _lookaheadB, _lookaheadC });
var laABC = SegmentSet.New(new Segment[] { _lookaheadA, _lookaheadB, _lookaheadC });
set1.SetLookahead(_item10, laAB);
set1.SetLookahead(_item11, laBC);
set1.SetLookahead(_item20, laABC);
Assert.That(set1.GetLookahead(_item10), Is.EqualTo(laAB));
Assert.That(set1.GetLookahead(_item11), Is.EqualTo(laBC));
Assert.That(set1.GetLookahead(_item20), Is.EqualTo(laABC));
set1.SubtractLookaheads(laB);
Assert.That(set1.GetLookahead(_item10), Is.EqualTo(laA));
Assert.That(set1.GetLookahead(_item11), Is.EqualTo(laC));
Assert.That(set1.GetLookahead(_item20), Is.EqualTo(laA.Union(laC)));
}
public void TryUnionLookahead()
{
var set1 = ParseItemSet.New(new ParseItem[] { _item10, _item11, _item20 });
var la1 = SegmentSet.New(new Segment[] { _lookaheadA, _lookaheadB });
var la2 = SegmentSet.New(new Segment[] { _lookaheadB, _lookaheadC });
var la3 = SegmentSet.New(new Segment[] { _lookaheadA, _lookaheadB, _lookaheadC });
Assert.That(set1.GetLookahead(_item10), Is.EqualTo(SegmentSet.EmptySet));
Assert.That(set1.GetLookahead(_item11), Is.EqualTo(SegmentSet.EmptySet));
Assert.That(set1.GetLookahead(_item20), Is.EqualTo(SegmentSet.EmptySet));
Assert.That(set1.TryUnionLookahead(_item10, la1), Is.EqualTo(true));
Assert.That(set1.TryUnionLookahead(_item11, la1), Is.EqualTo(true));
Assert.That(set1.GetLookahead(_item10), Is.EqualTo(la1));
Assert.That(set1.GetLookahead(_item11), Is.EqualTo(la1));
Assert.That(set1.GetLookahead(_item20), Is.EqualTo(SegmentSet.EmptySet));
Assert.That(set1.TryUnionLookahead(_item10, la2), Is.EqualTo(true));
Assert.That(set1.GetLookahead(_item10), Is.EqualTo(la3));
Assert.That(set1.GetLookahead(_item11), Is.EqualTo(la1));
Assert.That(set1.GetLookahead(_item20), Is.EqualTo(SegmentSet.EmptySet));
Assert.That(set1.TryUnionLookahead(_item10, la1), Is.EqualTo(false));
Assert.That(set1.GetLookahead(_item10), Is.EqualTo(la3));
Assert.That(set1.GetLookahead(_item11), Is.EqualTo(la1));
Assert.That(set1.GetLookahead(_item20), Is.EqualTo(SegmentSet.EmptySet));
}
public void SerializeSegmentSet()
{
SegmentSet set = new SegmentSet {
Name = "4010"
};
SegmentSpecification isa = new SegmentSpecification {
SegmentId = "ISA"
};
set.Segments.Add(isa);
isa.Elements.Add(new ElementSpecification
{
Name = "Author Info Qualifier",
Required = true,
MinLength = 2,
MaxLength = 2,
Type = ElementDataTypeEnum.Identifier
});
string xml = set.Serialize();
Trace.Write(xml);
SegmentSet copy = SegmentSet.Deserialize(xml);
SegmentSpecification isaCopy = copy.Segments.FirstOrDefault(s => s.SegmentId == "ISA");
Assert.IsNotNull(isaCopy);
Assert.AreEqual("ISA", isaCopy.SegmentId);
Assert.AreEqual("Author Info Qualifier", isaCopy.Elements[0].Name);
Assert.AreEqual(2, isaCopy.Elements[0].MinLength);
}
public void Intersect_Reuse()
{
var segment1 = new Segment("Segment1", false);
var segment2 = new Segment("Segment2", false);
var set1 = SegmentSet.New(new Segment[] { segment1, segment2 });
var set2 = SegmentSet.New(new Segment[] { segment1 });
Assert.That(set1.Intersection(set2), Is.SameAs(set2));
Assert.That(set2.Intersection(set1), Is.SameAs(set2));
}
public void Subtract_Reuse()
{
var segment1 = new Segment("Segment1", false);
var segment2 = new Segment("Segment2", false);
var set1 = SegmentSet.New(new Segment[] { segment1 });
var set2 = SegmentSet.New(new Segment[] { segment2 });
Assert.That(set1.Subtract(set2), Is.SameAs(set1));
Assert.That(set2.Subtract(set1), Is.SameAs(set2));
}
public void ToStringX()
{
var set1 = SegmentSet.New(new Segment[] { new Segment("a", true) });
var set2 = SegmentSet.New(new Segment[] { new Segment("A", false) });
Assert.That(SegmentSet.EmptySet.ToString(), Is.EqualTo(string.Empty));
Assert.That(SegmentSet.EpsilonSet.ToString(), Is.EqualTo("null"));
Assert.That(set1.ToString(), Is.EqualTo("a"));
Assert.That(set2.ToString(), Is.EqualTo("<A>"));
Assert.That(set1.Union(set2).Union(SegmentSet.EpsilonSet).ToString(), Is.EqualTo("null a <A>"));
}
public void Intersect()
{
var segment1 = new Segment("segment1", false);
var segment2 = new Segment("segment2", false);
var segment3 = new Segment("segment3", false);
var segment4 = new Segment("segment4", false);
var a = SegmentSet.New(new Segment[] { segment1, segment2 });
var b = SegmentSet.New(new Segment[] { segment2, segment3 });
var x = a.Intersection(b);
Assert.That(x.ContainsSegment(segment1), Is.EqualTo(false), "segment1");
Assert.That(x.ContainsSegment(segment2), Is.EqualTo(true), "segment2");
Assert.That(x.ContainsSegment(segment3), Is.EqualTo(false), "segment3");
Assert.That(x.ContainsSegment(segment4), Is.EqualTo(false), "segment4");
}
void PopulateTopLevelSegments()
{
if (_config.EntryPoints.Count > 0)
{
var segments = new Dictionary <Segment, bool>();
foreach (var entryPoint in _config.EntryPoints)
{
var segment = GetNonTerminal(entryPoint.NonTerminal.Text);
entryPoint.Segment = segment;
if (_ntTypes.TryGetValue(segment, out var cUsing))
{
entryPoint.Using = cUsing;
}
if (segments.ContainsKey(segment))
{
ReporterHelper.AddWarning(_reporter, entryPoint.NonTerminal, "The non-terminal <{0}> is already an entry point.", entryPoint.NonTerminal.Text);
}
else
{
segments.Add(segment, true);
}
}
_config.TopLevelSegments = SegmentSet.New(segments.Keys);
}
else if (_config.Productions.Count > 0)
{
_config.TopLevelSegments = SegmentSet.New(new Segment[]
{
_config.Productions[0].Segment,
});
_config.EntryPoints.Add(new ConfigEntryPoint()
{
Segment = _config.Productions[0].Segment,
NonTerminal = _config.Productions[0].Target,
Using = _config.Productions[0].Using,
});
}
else
{
_config.TopLevelSegments = SegmentSet.EmptySet;
}
}
public void CopyTo()
{
var segment1 = new Segment("segment1", false);
var segment2 = new Segment("segment2", false);
var segment3 = new Segment("segment3", false);
var set = SegmentSet.New(new Segment[] { segment1, segment2, segment3 });
var segments1 = new Segment[set.Count];
set.CopyTo(segments1, 0);
Assert.That(segments1, Is.EqualTo(new Segment[] { segment1, segment2, segment3 }));
var segments2 = new Segment[set.Count + 2];
set.CopyTo(segments2, 1);
Assert.That(segments2, Is.EqualTo(new Segment[] { null, segment1, segment2, segment3, null }));
}
public void New()
{
var segment1 = new Segment("segment1", true);
var segment2 = new Segment("segment2", true);
var set1 = SegmentSet.New(new Segment[] { segment1, segment2, segment2 });
var set2 = SegmentSet.New(new Segment[] { segment2, segment1 });
var set3 = SegmentSet.New(new Segment[] { segment2, segment2 });
Assert.That(set1.Equals(set2), Is.EqualTo(true));
Assert.That(set2.Equals(set1), Is.EqualTo(true));
Assert.That(set1.Equals(set3), Is.EqualTo(false));
Assert.That(set3.Equals(set1), Is.EqualTo(false));
Assert.That(set2.Equals(set3), Is.EqualTo(false));
Assert.That(set3.Equals(set2), Is.EqualTo(false));
}
public void IsSuperSetOf()
{
var segment1 = new Segment("segment1", false);
var segment2 = new Segment("segment2", false);
var segment3 = new Segment("segment3", false);
var segment4 = new Segment("segment4", false);
var set1 = SegmentSet.New(new Segment[] { segment1 });
var set2 = SegmentSet.New(new Segment[] { segment1, segment2 });
var set3 = SegmentSet.New(new Segment[] { segment2, segment3, segment4 });
Assert.That(set1.IsSupersetOf(set2), Is.EqualTo(false));
Assert.That(set1.IsSupersetOf(set3), Is.EqualTo(false));
Assert.That(set2.IsSupersetOf(set1), Is.EqualTo(true));
Assert.That(set2.IsSupersetOf(set3), Is.EqualTo(false));
Assert.That(set3.IsSupersetOf(set1), Is.EqualTo(false));
Assert.That(set3.IsSupersetOf(set2), Is.EqualTo(false));
}
Config ConstructSample2()
{
/*
* S := "id"
* | V ":=" E
*
* V := "id"
*
* E := V
* | "n"
*/
var s = new Segment("S", false);
var v = new Segment("V", false);
var e = new Segment("E", false);
var id = new Segment("id", true);
var assign = new Segment(":=", true);
var n = new Segment("n", true);
return(new Config()
{
TopLevelSegments = SegmentSet.New(new Segment[] { s, e, }),
Productions =
{
new ConfigProduction()
{
Target = new ConfigToken(ConfigTokenType.NonTerminal, null, null, "S"),
Segment = s,
Rules =
{
new ConfigRule()
{
Segments =
{
new ConfigSegment()
{
Token = new ConfigToken(ConfigTokenType.Label, null, null, "id"),
Segment = id,
},
},
Production = new Production(s, ImmutableArray.Create(id)),
},
new ConfigRule()
{
Segments =
{
new ConfigSegment()
{
Token = new ConfigToken(ConfigTokenType.NonTerminal, null, null, "V"),
Segment = v,
},
new ConfigSegment()
{
Token = new ConfigToken(ConfigTokenType.Label, null, null, ":="),
Segment = assign,
},
new ConfigSegment()
{
Token = new ConfigToken(ConfigTokenType.NonTerminal, null, null, "E"),
Segment = e,
},
},
Production = new Production(s, ImmutableArray.Create(v, assign, e)),
},
},
},
new ConfigProduction()
{
Target = new ConfigToken(ConfigTokenType.NonTerminal, null, null, "V"),
Segment = v,
Rules =
{
new ConfigRule()
{
Segments =
{
new ConfigSegment()
{
Token = new ConfigToken(ConfigTokenType.Label, null, null, "id"),
Segment = id,
},
},
Production = new Production(v, ImmutableArray.Create(id)),
},
},
},
new ConfigProduction()
{
Target = new ConfigToken(ConfigTokenType.NonTerminal, null, null, "E"),
Segment = e,
Rules =
{
new ConfigRule()
{
Segments =
{
new ConfigSegment()
{
Token = new ConfigToken(ConfigTokenType.NonTerminal, null, null, "V"),
Segment = v,
},
},
Production = new Production(e, ImmutableArray.Create(v)),
},
new ConfigRule()
{
Segments =
{
new ConfigSegment()
{
Token = new ConfigToken(ConfigTokenType.Label, null, null, "n"),
Segment = n,
},
},
Production = new Production(e, ImmutableArray.Create(n)),
},
},
},
},
});
}
Config ConstructSample1()
{
/*
* A := "(" A ")"
* | "a"
*/
var nonTerminal = new Segment("A", false);
var terminal = new Segment("a", true);
var openParen = new Segment("(", true);
var closeParen = new Segment(")", true);
return(new Config()
{
TopLevelSegments = SegmentSet.New(new Segment[] { nonTerminal }),
Productions =
{
new ConfigProduction()
{
Target = new ConfigToken(ConfigTokenType.NonTerminal, null, null, "A"),
Segment = nonTerminal,
Rules =
{
new ConfigRule()
{
Segments =
{
new ConfigSegment()
{
Token = new ConfigToken(ConfigTokenType.Label, null, null, "("),
Segment = openParen,
},
new ConfigSegment()
{
Token = new ConfigToken(ConfigTokenType.NonTerminal, null, null, "A"),
Segment = nonTerminal,
},
new ConfigSegment()
{
Token = new ConfigToken(ConfigTokenType.Label, null, null, ")"),
Segment = closeParen,
},
},
Production = new Production(nonTerminal, ImmutableArray.Create(openParen, nonTerminal, closeParen)),
},
new ConfigRule()
{
Segments =
{
new ConfigSegment()
{
Token = new ConfigToken(ConfigTokenType.Label, null, null, "a"),
Segment = terminal,
},
},
Production = new Production(nonTerminal, ImmutableArray.Create(terminal)),
},
},
},
},
});
}
