public void ImplementInterface_Should_AppendConditionToVerifier()
{
var f = new FilteredClasses(new [] { _mockClass1.Object });
var sut = new ClassRule(f, false);
sut.ImplementInterface().That().HasNameMatching(nameof(IInterfaceOfClass1)).Check();
}
private ClassRule CreateSystemUnderTest()
{
var verifierMock = new Mock <IAssertionVerifier <IClassInfo> >(MockBehavior.Loose);
verifierMock.Setup(v => v.AppendCondition(It.IsAny <Predicate <IClassInfo> >())).Callback <Predicate <IClassInfo> >(p => _savedPredicate = p);
var filter = new FilteredClasses(new [] { _mockClass1.Object, _mockClass2.Object });
verifierMock.SetupGet(v => v.Items).Returns(filter);
var sut = new ClassRule(verifierMock.Object);
return(sut);
}
internal override Rule DoParse()
{
// ============ MUST NEVER RETURN NULL ======================
Rule rule;
//var w = GetWord();
switch (CurrentChar)
{
case '@': // media query & other
{
// non cumulative
rule = new DirectiveRule
{
Selector = Parse <DirectiveSelector>(),
};
break;
}
case '{':
// meaningless block
AddError(ErrorCode.UnexpectedToken, "{");
rule = new OrphanBlockRule();
break;
case '}':
// unexpected block end
Index++; // will throw a block mismatch exception, and resume parsing after it.
throw new ParsingException("Unexpected token '}'"); // will never be thrown
default: // classic selector
var sel = Parse <Selector>();
if (sel == null)
{
return(null);
}
rule = new ClassRule
{
Selector = sel,
};
break;
}
if (End)
{
AddError(ErrorCode.UnexpectedEnd, "end of rule");
return(new NotParsableBlockRule());
}
if (rule.ExpectedBodyType == Rule.BodyType.None)
{
if (CurrentChar != ';')
{
AddError(ErrorCode.ExpectingToken, ";");
}
else
{
Index++;
}
return(rule);
}
if (CurrentChar != '{')
{
if (CurrentChar == ';')
{
Index++;
}
AddError(ErrorCode.ExpectingBody, "This rule requires a body");
return(rule);
}
if (rule.ExpectedBodyType == Rule.BodyType.Properties)
{
rule.Properties = ParseBlock <Property>(true);
}
else
{
rule.ChildRules = ParseBlock <Rule>(true);
}
return(rule);
}
