public void ConstructorShouldSetParent()
{
var parent = new ParsingScope(_parsingScopes, _factory.Create("A1"));
var scope = new ParsingScope(_parsingScopes, parent, _factory.Create("A2"));
Assert.AreEqual(parent, scope.Parent);
}
public void ConstructorShouldSetAddress()
{
var expectedAddress = _factory.Create("A1");
var scope = new ParsingScope(_parsingScopes, expectedAddress);
Assert.AreEqual(expectedAddress, scope.Address);
}
public void ScopeShouldCallKillScopeOnDispose()
{
var scope = new ParsingScope(_parsingScopes, _factory.Create("A1"));
((IDisposable)scope).Dispose();
_parsingScopes.AssertWasCalled(x => x.KillScope(scope));
}
public void ScopeShouldCallKillScopeOnDispose()
{
var scope = new ParsingScope(_parsingScopes, _factory.Create("A1"));
((IDisposable)scope).Dispose();
A.CallTo(() => _parsingScopes.KillScope(scope)).MustHaveHappened();
}
public virtual void Add(ParsingScope parsingScope, RangeAddress rangeAddress)
{
if (!_rangeAddresses.ContainsKey(parsingScope.ScopeId))
{
_rangeAddresses.Add(parsingScope.ScopeId, new List<RangeAddress>());
}
_rangeAddresses[parsingScope.ScopeId].Add(rangeAddress);
}
public void ConstructorShouldSetScopeId()
{
var scopes = new ParsingScopes(_lifeTimeEventHandler);
var scope = new ParsingScope(scopes, RangeAddress.Empty);
var dependency = new FormulaDependency(scope);
Assert.AreEqual(scope.ScopeId, dependency.ScopeId);
}
public virtual void Add(ParsingScope parsingScope, RangeAddress rangeAddress)
{
if (!_rangeAddresses.ContainsKey(parsingScope.ScopeId))
{
_rangeAddresses.Add(parsingScope.ScopeId, new List <RangeAddress>());
}
_rangeAddresses[parsingScope.ScopeId].Add(rangeAddress);
}
public SubcircuitDeviceDeferredStatement(ParsingScope scope, string deviceName, int[] terminals,
Token subcircuitName) : base(scope)
{
this.deviceName = deviceName;
this.terminals = terminals;
this.subcircuitName = subcircuitName;
errors = new List <SpiceParserError>();
}
public void ClearShouldClearDictionary()
{
var scope = new ParsingScope(_scopes, _factory.Create("A1"));
_formulaDependencies.AddFormulaScope(scope);
Assert.AreEqual(1, _formulaDependencies.Dependencies.Count());
_formulaDependencies.Clear();
Assert.AreEqual(0, _formulaDependencies.Dependencies.Count());
}
public void ConstructorShouldSetAddress()
{
var scopes = new ParsingScopes(_lifeTimeEventHandler);
var expectedAddress = _factory.Create("A1");
var scope = new ParsingScope(scopes, expectedAddress);
var dependency = new FormulaDependency(scope);
Assert.AreEqual(expectedAddress, dependency.Address);
}
public DeferredPrintStatement(ParsingScope scope, Token token, string analysisType) : base(scope)
{
this.token = token;
this.analysisType = analysisType;
var s = token.Value;
var parStart = s.IndexOf('(');
var parEnd = s.LastIndexOf(')');
stat = token.Value.Substring(0, parStart);
name = token.Value.Substring(parStart + 1, parEnd - parStart - 1);
errors = new List <SpiceParserError>();
}
/// <summary>Gets indices of the nodes represented by given set of tokens. Adds relevant errors into the errors collection.</summary>
/// <param name="tokens"></param>
/// <returns></returns>
private int[] GetNodeIndices(IEnumerable <Token> tokens, ParsingScope context)
{
return(tokens.Select(token =>
{
if (!context.SymbolTable.TryGetOrCreateNode(token.Value, out var node))
{
node = -1;
context.Errors.Add(token.ToError(SpiceParserErrorCode.NotANode));
}
return node;
}).ToArray());
}
public virtual void CheckCircularReference(ParsingScope scope, RangeAddress rangeAddress)
{
var conflictingScope = (from r in _rangeAddresses
where r.Key != scope.ScopeId
&& r.Value.Exists(x => x.CollidesWith(rangeAddress))
select r).FirstOrDefault();
if(conflictingScope.Value != null)
{
var conflictingRange = conflictingScope.Value.Find(x => x.CollidesWith(rangeAddress));
var errMsg = string.Format("Circular reference detected between {0} and {1}", conflictingRange, rangeAddress);
throw new CircularReferenceException(errMsg);
}
}
public virtual void CheckCircularReference(ParsingScope scope, RangeAddress rangeAddress)
{
var conflictingScope = (from r in _rangeAddresses
where r.Key != scope.ScopeId &&
r.Value.Exists(x => x.CollidesWith(rangeAddress))
select r).FirstOrDefault();
if (conflictingScope.Value != null)
{
var conflictingRange = conflictingScope.Value.Find(x => x.CollidesWith(rangeAddress));
var errMsg = string.Format("Circular reference detected between {0} and {1}", conflictingRange, rangeAddress);
throw new CircularReferenceException(errMsg);
}
}
public void ShouldAddReferenceToParent()
{
var parentScope = new ParsingScope(_scopes, _factory.Create("A1"));
var parentDependency = MockRepository.GenerateStub <FormulaDependency>(parentScope);
_formulaDependencyFactory.Stub(x => x.Create(parentScope)).Return(parentDependency);
_formulaDependencies.AddFormulaScope(parentScope);
var childScope = new ParsingScope(_scopes, parentScope, _factory.Create("A2"));
var childDependency = MockRepository.GenerateStub <FormulaDependency>(childScope);
_formulaDependencyFactory.Stub(x => x.Create(childScope)).Return(childDependency);
_formulaDependencies.AddFormulaScope(childScope);
parentDependency.AssertWasCalled(x => x.AddReferenceTo(childScope.Address));
}
public void AddFormulaScope(ParsingScope parsingScope)
{
//var dependency = _formulaDependencyFactory.Create(parsingScope);
//var address = parsingScope.Address.ToString();
//if (!_dependencies.ContainsKey(address))
//{
// _dependencies.Add(address, dependency);
//}
//if (parsingScope.Parent != null)
//{
// var parentAddress = parsingScope.Parent.Address.ToString();
// if (_dependencies.ContainsKey(parentAddress))
// {
// var parent = _dependencies[parentAddress];
// parent.AddReferenceTo(parsingScope.Address);
// dependency.AddReferenceFrom(parent.Address);
// }
//}
}
public void AddFormulaScope(ParsingScope parsingScope)
{
//var dependency = _formulaDependencyFactory.Create(parsingScope);
//var address = parsingScope.Address.ToString();
//if (!_dependencies.ContainsKey(address))
//{
// _dependencies.Add(address, dependency);
//}
//if (parsingScope.Parent != null)
//{
// var parentAddress = parsingScope.Parent.Address.ToString();
// if (_dependencies.ContainsKey(parentAddress))
// {
// var parent = _dependencies[parentAddress];
// parent.AddReferenceTo(parsingScope.Address);
// dependency.AddReferenceFrom(parent.Address);
// }
//}
}
public virtual void Add(ParsingScope parsingScope, string rangeAddress)
{
Add(parsingScope, RangeAddress.Parse(rangeAddress));
}
public ModeledDeviceDeferedStatement(ParsingScope scope, Action <TModel, CircuitBuilder> addFunc,
Token modelNameToken) : base(scope)
{
this.addFunc = addFunc;
this.modelNameToken = modelNameToken;
}
public virtual void Add(ParsingScope parsingScope, string rangeAddress)
{
Add(parsingScope, RangeAddress.Parse(rangeAddress));
}
public virtual FormulaDependency Create(ParsingScope scope)
{
return(new FormulaDependency(scope));
}
public VoltageSourceDependentDeferredStatement(ParsingScope scope, Token vsourcName,
Action <CircuitBuilder, VoltageSource> builderFunc)
: base(scope, b => builderFunc(b, FindVoltageSource(b, vsourcName.Value)))
{
this.vsourcName = vsourcName;
}
public virtual FormulaDependency Create(ParsingScope scope)
{
return new FormulaDependency(scope);
}
public DeferredSubcktStatement(ParsingScope scope, Token[] tokens) : base(scope)
{
this.tokens = tokens;
errors = new List <SpiceParserError>();
}
public FormulaDependency(ParsingScope scope)
{
ScopeId = scope.ScopeId;
Address = scope.Address;
}
public void Setup()
{
_parsingContext = ParsingContext.Create();
_scope = _parsingContext.Scopes.NewScope(RangeAddress.Empty);
}
public SimpleDeviceDeferredStatement(ParsingScope scope, Action <CircuitBuilder> builderFunc) : base(scope)
{
this.builderFunc = builderFunc;
}
public FormulaDependency(ParsingScope scope)
{
ScopeId = scope.ScopeId;
Address = scope.Address;
}
protected DeferredStatement(ParsingScope scope)
{
Scope = scope;
}
