//throws Exception
protected void checkDecision( Grammar g,
int decision,
string expecting,
int[] expectingUnreachableAlts,
int[] expectingNonDetAlts,
string expectingAmbigInput,
int[] expectingInsufficientPredAlts,
int[] expectingDanglingAlts,
int expectingNumWarnings,
bool hasPredHiddenByAction )
{
DecisionProbe.verbose = true; // make sure we get all error info
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener( equeue );
CodeGenerator generator = new CodeGenerator( newTool(), g, "Java" );
g.CodeGenerator = generator;
// mimic actions of org.antlr.Tool first time for grammar g
if ( g.NumberOfDecisions == 0 )
{
g.BuildNFA();
g.CreateLookaheadDFAs( false );
}
if ( equeue.size() != expectingNumWarnings )
{
Console.Error.WriteLine( "Warnings issued: " + equeue );
}
Assert.AreEqual(expectingNumWarnings, equeue.size(), "unexpected number of expected problems");
DFA dfa = g.GetLookaheadDFA( decision );
FASerializer serializer = new FASerializer( g );
string result = serializer.Serialize( dfa.StartState );
//System.out.print(result);
var unreachableAlts = dfa.UnreachableAlts;
// make sure unreachable alts are as expected
if ( expectingUnreachableAlts != null )
{
BitSet s = new BitSet();
s.AddAll( expectingUnreachableAlts );
BitSet s2 = new BitSet();
s2.AddAll( unreachableAlts );
Assert.AreEqual(s, s2, "unreachable alts mismatch");
}
else
{
Assert.AreEqual(0, unreachableAlts != null ? unreachableAlts.Count : 0, "unreachable alts mismatch");
}
// check conflicting input
if ( expectingAmbigInput != null )
{
// first, find nondet message
Message msg = getNonDeterminismMessage( equeue.warnings );
Assert.IsNotNull(msg, "no nondeterminism warning?");
Assert.IsTrue(msg is GrammarNonDeterminismMessage, "expecting nondeterminism; found " + msg.GetType().Name);
GrammarNonDeterminismMessage nondetMsg =
getNonDeterminismMessage( equeue.warnings );
var labels =
nondetMsg.probe.GetSampleNonDeterministicInputSequence( nondetMsg.problemState );
string input = nondetMsg.probe.GetInputSequenceDisplay( labels );
Assert.AreEqual( expectingAmbigInput, input );
}
// check nondet alts
if ( expectingNonDetAlts != null )
{
GrammarNonDeterminismMessage nondetMsg =
getNonDeterminismMessage( equeue.warnings );
Assert.IsNotNull(nondetMsg, "found no nondet alts; expecting: " + str(expectingNonDetAlts));
var nonDetAlts =
nondetMsg.probe.GetNonDeterministicAltsForState( nondetMsg.problemState );
// compare nonDetAlts with expectingNonDetAlts
BitSet s = new BitSet();
s.AddAll( expectingNonDetAlts );
BitSet s2 = new BitSet();
s2.AddAll( nonDetAlts );
Assert.AreEqual(s, s2, "nondet alts mismatch");
Assert.AreEqual(hasPredHiddenByAction, nondetMsg.problemState.Dfa.HasPredicateBlockedByAction, "mismatch between expected hasPredHiddenByAction");
}
else
{
// not expecting any nondet alts, make sure there are none
GrammarNonDeterminismMessage nondetMsg =
getNonDeterminismMessage( equeue.warnings );
Assert.IsNull(nondetMsg, "found nondet alts, but expecting none");
}
if ( expectingInsufficientPredAlts != null )
{
GrammarInsufficientPredicatesMessage insuffPredMsg =
getGrammarInsufficientPredicatesMessage( equeue.warnings );
Assert.IsNotNull(insuffPredMsg, "found no GrammarInsufficientPredicatesMessage alts; expecting: " + str(expectingNonDetAlts));
var locations = insuffPredMsg.altToLocations;
var actualAlts = locations.Keys;
BitSet s = new BitSet();
s.AddAll( expectingInsufficientPredAlts );
BitSet s2 = new BitSet();
s2.AddAll( actualAlts );
Assert.AreEqual(s, s2, "mismatch between insufficiently covered alts");
Assert.AreEqual(hasPredHiddenByAction, insuffPredMsg.problemState.Dfa.HasPredicateBlockedByAction, "mismatch between expected hasPredHiddenByAction");
}
else
{
// not expecting any nondet alts, make sure there are none
GrammarInsufficientPredicatesMessage nondetMsg =
getGrammarInsufficientPredicatesMessage( equeue.warnings );
if ( nondetMsg != null )
{
Console.Out.WriteLine( equeue.warnings );
}
Assert.IsNull(nondetMsg, "found insufficiently covered alts, but expecting none");
}
Assert.AreEqual( expecting, result );
}
protected void checkDecision(Grammar g,
int decision,
string expecting,
int[] expectingUnreachableAlts,
int[] expectingNonDetAlts,
string expectingAmbigInput,
int[] expectingInsufficientPredAlts,
int[] expectingDanglingAlts,
int expectingNumWarnings,
bool hasPredHiddenByAction)
//throws Exception
{
DecisionProbe.verbose = true; // make sure we get all error info
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue);
CodeGenerator generator = new CodeGenerator(newTool(), g, "Java");
g.CodeGenerator = generator;
// mimic actions of org.antlr.Tool first time for grammar g
if (g.NumberOfDecisions == 0)
{
g.BuildNFA();
g.CreateLookaheadDFAs(false);
}
if (equeue.size() != expectingNumWarnings)
{
Console.Error.WriteLine("Warnings issued: " + equeue);
}
Assert.AreEqual(expectingNumWarnings, equeue.size(), "unexpected number of expected problems");
DFA dfa = g.GetLookaheadDFA(decision);
FASerializer serializer = new FASerializer(g);
string result = serializer.Serialize(dfa.StartState);
//System.out.print(result);
var unreachableAlts = dfa.UnreachableAlts;
// make sure unreachable alts are as expected
if (expectingUnreachableAlts != null)
{
BitSet s = new BitSet();
s.AddAll(expectingUnreachableAlts);
BitSet s2 = new BitSet();
s2.AddAll(unreachableAlts);
Assert.AreEqual(s, s2, "unreachable alts mismatch");
}
else
{
Assert.AreEqual(0, unreachableAlts != null ? unreachableAlts.Count : 0, "unreachable alts mismatch");
}
// check conflicting input
if (expectingAmbigInput != null)
{
// first, find nondet message
Message msg = getNonDeterminismMessage(equeue.warnings);
Assert.IsNotNull(msg, "no nondeterminism warning?");
Assert.IsTrue(msg is GrammarNonDeterminismMessage, "expecting nondeterminism; found " + msg.GetType().Name);
GrammarNonDeterminismMessage nondetMsg =
getNonDeterminismMessage(equeue.warnings);
var labels =
nondetMsg.probe.GetSampleNonDeterministicInputSequence(nondetMsg.problemState);
string input = nondetMsg.probe.GetInputSequenceDisplay(labels);
Assert.AreEqual(expectingAmbigInput, input);
}
// check nondet alts
if (expectingNonDetAlts != null)
{
GrammarNonDeterminismMessage nondetMsg =
getNonDeterminismMessage(equeue.warnings);
Assert.IsNotNull(nondetMsg, "found no nondet alts; expecting: " + str(expectingNonDetAlts));
var nonDetAlts =
nondetMsg.probe.GetNonDeterministicAltsForState(nondetMsg.problemState);
// compare nonDetAlts with expectingNonDetAlts
BitSet s = new BitSet();
s.AddAll(expectingNonDetAlts);
BitSet s2 = new BitSet();
s2.AddAll(nonDetAlts);
Assert.AreEqual(s, s2, "nondet alts mismatch");
Assert.AreEqual(hasPredHiddenByAction, nondetMsg.problemState.Dfa.HasPredicateBlockedByAction, "mismatch between expected hasPredHiddenByAction");
}
else
{
// not expecting any nondet alts, make sure there are none
GrammarNonDeterminismMessage nondetMsg =
getNonDeterminismMessage(equeue.warnings);
Assert.IsNull(nondetMsg, "found nondet alts, but expecting none");
}
if (expectingInsufficientPredAlts != null)
{
GrammarInsufficientPredicatesMessage insuffPredMsg =
getGrammarInsufficientPredicatesMessage(equeue.warnings);
Assert.IsNotNull(insuffPredMsg, "found no GrammarInsufficientPredicatesMessage alts; expecting: " + str(expectingNonDetAlts));
var locations = insuffPredMsg.altToLocations;
var actualAlts = locations.Keys;
BitSet s = new BitSet();
s.AddAll(expectingInsufficientPredAlts);
BitSet s2 = new BitSet();
s2.AddAll(actualAlts);
Assert.AreEqual(s, s2, "mismatch between insufficiently covered alts");
Assert.AreEqual(hasPredHiddenByAction, insuffPredMsg.problemState.Dfa.HasPredicateBlockedByAction, "mismatch between expected hasPredHiddenByAction");
}
else
{
// not expecting any nondet alts, make sure there are none
GrammarInsufficientPredicatesMessage nondetMsg =
getGrammarInsufficientPredicatesMessage(equeue.warnings);
if (nondetMsg != null)
{
Console.Out.WriteLine(equeue.warnings);
}
Assert.IsNull(nondetMsg, "found insufficiently covered alts, but expecting none");
}
Assert.AreEqual(expecting, result);
}
//throws Exception
protected void checkDecision( Grammar g,
int decision,
string expecting,
int[] expectingUnreachableAlts,
int[] expectingNonDetAlts,
string expectingAmbigInput,
int[] expectingDanglingAlts,
int expectingNumWarnings )
{
DecisionProbe.verbose = true; // make sure we get all error info
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener( equeue );
// mimic actions of org.antlr.Tool first time for grammar g
if ( g.NumberOfDecisions == 0 )
{
g.BuildNFA();
g.CreateLookaheadDFAs( false );
}
CodeGenerator generator = new CodeGenerator( newTool(), g, "Java" );
g.CodeGenerator = generator;
if ( equeue.size() != expectingNumWarnings )
{
Console.Error.WriteLine( "Warnings issued: " + equeue );
}
Assert.AreEqual(expectingNumWarnings, equeue.size(), "unexpected number of expected problems");
DFA dfa = g.GetLookaheadDFA( decision );
Assert.IsNotNull( dfa, "no DFA for decision " + decision );
FASerializer serializer = new FASerializer( g );
string result = serializer.Serialize( dfa.StartState );
var unreachableAlts = dfa.UnreachableAlts;
// make sure unreachable alts are as expected
if ( expectingUnreachableAlts != null )
{
BitSet s = new BitSet();
s.AddAll( expectingUnreachableAlts );
BitSet s2 = new BitSet();
s2.AddAll( unreachableAlts );
Assert.AreEqual(s, s2, "unreachable alts mismatch");
}
else
{
Assert.AreEqual(0, unreachableAlts != null ? unreachableAlts.Count : 0, "number of unreachable alts");
}
// check conflicting input
if ( expectingAmbigInput != null )
{
// first, find nondet message
Message msg = (Message)equeue.warnings[0];
Assert.IsTrue(msg is GrammarNonDeterminismMessage, "expecting nondeterminism; found " + msg.GetType().Name);
GrammarNonDeterminismMessage nondetMsg =
getNonDeterminismMessage( equeue.warnings );
var labels =
nondetMsg.probe.GetSampleNonDeterministicInputSequence( nondetMsg.problemState );
string input = nondetMsg.probe.GetInputSequenceDisplay( labels );
Assert.AreEqual( expectingAmbigInput, input );
}
// check nondet alts
if ( expectingNonDetAlts != null )
{
RecursionOverflowMessage recMsg = null;
GrammarNonDeterminismMessage nondetMsg =
getNonDeterminismMessage( equeue.warnings );
IList<int> nonDetAlts = null;
if ( nondetMsg != null )
{
nonDetAlts =
nondetMsg.probe.GetNonDeterministicAltsForState( nondetMsg.problemState );
}
else
{
recMsg = getRecursionOverflowMessage( equeue.warnings );
if ( recMsg != null )
{
//nonDetAlts = new ArrayList(recMsg.alts);
}
}
// compare nonDetAlts with expectingNonDetAlts
BitSet s = new BitSet();
s.AddAll( expectingNonDetAlts );
BitSet s2 = new BitSet();
s2.AddAll( nonDetAlts );
Assert.AreEqual(s, s2, "nondet alts mismatch");
Assert.IsTrue(nondetMsg != null || recMsg != null, "found no nondet alts; expecting: " + str(expectingNonDetAlts));
}
else
{
// not expecting any nondet alts, make sure there are none
GrammarNonDeterminismMessage nondetMsg =
getNonDeterminismMessage( equeue.warnings );
Assert.IsNull(nondetMsg, "found nondet alts, but expecting none");
}
Assert.AreEqual( expecting, result );
}
