internal PluginRequirement( PluginRequirementCollection holder, Guid pluginID, RunningRequirement requirement )
: this( holder )
{
Debug.Assert( pluginID != null );
PluginId = pluginID;
_req = requirement;
}
internal PluginRequirement(PluginRequirementCollection holder, Guid pluginID, RunningRequirement requirement)
: this( holder )
{
Debug.Assert(pluginID != null);
PluginId = pluginID;
_req = requirement;
}
/// <summary>
/// Initializes a new <see cref="RequirementLayer"/>.
/// </summary>
/// <param name="layerName">Optional name for the requirements.</param>
public RequirementLayer(string layerName)
{
LayerName = layerName;
_pluginRequirements = new PluginRequirementCollection();
_serviceRequirements = new ServiceRequirementCollection();
}
internal PluginRequirement(PluginRequirementCollection holder)
{
Debug.Assert(holder != null);
_holder = holder;
}
/// <summary>
/// Initializes a new <see cref="RequirementLayer"/>.
/// </summary>
/// <param name="layerName">Optional name for the requirements.</param>
public RequirementLayer( string layerName )
{
LayerName = layerName;
_pluginRequirements = new PluginRequirementCollection();
_serviceRequirements = new ServiceRequirementCollection();
}
internal PluginRequirement( PluginRequirementCollection holder )
{
Debug.Assert( holder != null );
_holder = holder;
}
void PluginRequirementCollectionEvents( PluginRequirementCollection collection )
{
Guid id = Guid.NewGuid();
PluginRequirementCollectionChangingEventArgs lastChanging = null;
PluginRequirementCollectionChangedEventArgs lastChanged = null;
int changingCount = 0;
int changedCount = 0;
collection.Changing += ( o, e ) => { lastChanging = e; changingCount++; };
collection.Changed += ( o, e ) => { lastChanged = e; changedCount++; };
// Check add
PluginRequirement req = collection.AddOrSet( id, RunningRequirement.MustExistAndRun );
Assert.That( changedCount == 1 && changingCount == 1 );
Assert.That( lastChanging.Action == CK.Core.ChangeStatus.Add );
Assert.That( lastChanged.Action == CK.Core.ChangeStatus.Add );
Assert.That( lastChanging.Collection == collection );
Assert.That( lastChanged.Collection == collection );
Assert.That( lastChanging.PluginId == id );
Assert.That( lastChanged.PluginId == id );
Assert.That( lastChanging.Requirement == RunningRequirement.MustExistAndRun );
Assert.That( lastChanged.Requirement == RunningRequirement.MustExistAndRun );
changedCount = 0; changingCount = 0;
// Check delete : from the collection
collection.Remove( id );
Assert.That( changedCount == 1 && changingCount == 1 );
Assert.That( lastChanging.Action == CK.Core.ChangeStatus.Delete );
Assert.That( lastChanged.Action == CK.Core.ChangeStatus.Delete );
Assert.That( lastChanging.Collection == collection );
Assert.That( lastChanged.Collection == collection );
Assert.That( lastChanging.PluginId == id );
Assert.That( lastChanged.PluginId == id );
Assert.That( lastChanging.Requirement == RunningRequirement.MustExistAndRun );
Assert.That( lastChanged.Requirement == RunningRequirement.MustExistAndRun );
changedCount = 0; changingCount = 0;
// Check clear
collection.Clear();
Assert.That( changedCount == 1 && changingCount == 1 );
Assert.That( lastChanging.Action == CK.Core.ChangeStatus.ContainerClear );
Assert.That( lastChanged.Action == CK.Core.ChangeStatus.ContainerClear );
Assert.That( lastChanging.Collection == collection );
Assert.That( lastChanged.Collection == collection );
Assert.That( lastChanging.PluginId == Guid.Empty );
Assert.That( lastChanged.PluginId == Guid.Empty );
Assert.That( lastChanging.Requirement == 0 );
Assert.That( lastChanged.Requirement == 0 );
}
public void TestPluginRequirementCollectionEvents()
{
int createdEventFired = 0;
int removedEventFired = 0;
int updatedEventFired = 0;
int clearedEventFired = 0;
int creatingEventFired = 0;
int removingEventFired = 0;
int updatingEventFired = 0;
int clearingEventFired = 0;
bool cancel = false;
Guid changingPluginId = Guid.Empty;
RunningRequirement previousRequirement = RunningRequirement.OptionalTryStart;
RunningRequirement newRequirement = RunningRequirement.OptionalTryStart;
PluginRequirement lastRequirementCreated = null;
PluginRequirement lastRequirementRemoved = null;
IPluginRequirementCollection reqs = new PluginRequirementCollection();
reqs.Changing += ( sender, args ) =>
{
switch( args.Action )
{
case CK.Core.ChangeStatus.Update:
updatingEventFired++;
if( !cancel )
previousRequirement = args.Collection.Find( args.PluginId ).Requirement;
break;
case CK.Core.ChangeStatus.Add:
creatingEventFired++;
break;
case CK.Core.ChangeStatus.Delete:
removingEventFired++;
break;
case CK.Core.ChangeStatus.ContainerClear:
clearingEventFired++;
break;
}
if( cancel )
args.Cancel = true;
};
reqs.Changed += ( sender, args ) =>
{
switch( args.Action )
{
case CK.Core.ChangeStatus.Update:
updatedEventFired++;
newRequirement = args.Requirement;
break;
case CK.Core.ChangeStatus.Add:
lastRequirementCreated = args.Collection.Find( args.PluginId );
createdEventFired++;
break;
case CK.Core.ChangeStatus.Delete:
lastRequirementRemoved = args.Collection.Find( args.PluginId );
removedEventFired++;
break;
case CK.Core.ChangeStatus.ContainerClear:
clearedEventFired++;
break;
}
};
PluginRequirement req = reqs.AddOrSet( Guid.NewGuid(), RunningRequirement.MustExistAndRun );
Assert.That( lastRequirementCreated == req );
Assert.That( createdEventFired == 1 );
Assert.That( creatingEventFired == 1 );
PluginRequirement req1 = reqs.AddOrSet( Guid.NewGuid(), RunningRequirement.MustExistAndRun );
Assert.That( lastRequirementCreated == req1 );
Assert.That( createdEventFired == 2 );
Assert.That( creatingEventFired == 2 );
PluginRequirement req2 = reqs.AddOrSet( Guid.NewGuid(), RunningRequirement.MustExistAndRun );
Assert.That( lastRequirementCreated == req2 );
Assert.That( createdEventFired == 3 );
Assert.That( creatingEventFired == 3 );
reqs.AddOrSet( req2.PluginId, RunningRequirement.MustExist );
Assert.That( previousRequirement == RunningRequirement.MustExistAndRun );
Assert.That( newRequirement == RunningRequirement.MustExist );
Assert.That( updatingEventFired == 1 );
Assert.That( updatedEventFired == 1 );
// Now, cancel is true, nothing should be done
cancel = true;
reqs.AddOrSet( req2.PluginId, RunningRequirement.Optional );
Assert.That( previousRequirement == RunningRequirement.MustExistAndRun );
Assert.That( newRequirement == RunningRequirement.MustExist );
Assert.That( updatingEventFired == 2 );
Assert.That( updatedEventFired == 1 );
cancel = false;
reqs.Clear();
Assert.That( clearedEventFired, Is.EqualTo( 1 ) );
}
public void TestPluginRequirementCollectionUpdate()
{
bool updated = false;
Guid guid1 = Guid.NewGuid();
Guid guid2 = Guid.NewGuid();
Guid guid3 = Guid.NewGuid();
IPluginRequirementCollection reqs = new PluginRequirementCollection( );
reqs.Changed += ( o, e ) => {if (e.Action == CK.Core.ChangeStatus.Update)
updated = true;
};
PluginRequirement req = reqs.AddOrSet( guid1, RunningRequirement.MustExistAndRun );
Assert.That( reqs.Count == 1 );
//Assert.That( (req.Source == reqs.Source) && (reqs.Source == ctx) );
PluginRequirement req1 = reqs.AddOrSet( guid2, RunningRequirement.MustExistAndRun );
Assert.That( reqs.Count == 2 );
PluginRequirement req2 = reqs.AddOrSet( guid3, RunningRequirement.MustExistAndRun );
Assert.That( reqs.Count == 3 );
Assert.That( reqs.Contains( req2 ) && reqs.Contains( req1 ) && reqs.Contains( req ) );
PluginRequirement req3 = reqs.AddOrSet( guid3, RunningRequirement.Optional );
Assert.That( updated );
Assert.That( req2 == req3 );
Assert.That( reqs.Count == 3 );
}
public void TestPluginRequirementCollectionEnumerable()
{
Guid guid0 = Guid.NewGuid();
Guid guid1 = Guid.NewGuid();
Guid guid2 = Guid.NewGuid();
IPluginRequirementCollection reqs = new PluginRequirementCollection( );
PluginRequirement req0 = reqs.AddOrSet( guid0, RunningRequirement.MustExistAndRun );
Assert.That( reqs.Count == 1 );
PluginRequirement req1 = reqs.AddOrSet( guid1, RunningRequirement.Optional );
Assert.That( reqs.Count == 2 );
PluginRequirement req2 = reqs.AddOrSet( guid2, RunningRequirement.OptionalTryStart );
Assert.That( reqs.Count == 3 );
Assert.That( reqs.Contains( req2 ) && reqs.Contains( req1 ) && reqs.Contains( req0 ) );
reqs.Remove( guid2 );
Assert.That( reqs.Count == 2 );
Assert.That( !reqs.Contains( req2 ) );
int passed = 0;
foreach( PluginRequirement o in reqs )
{
if( o.PluginId == guid0 )
{
Assert.That( o.Requirement == RunningRequirement.MustExistAndRun );
passed++;
}
if( o.PluginId == guid1 )
{
Assert.That( o.Requirement == RunningRequirement.Optional );
passed++;
}
}
Assert.That( passed, Is.EqualTo( 2 ) );
reqs.Clear();
Assert.That( reqs.Count == 0 );
Assert.That( ((PluginRequirement)req0).Holder == null );
Assert.That( ((PluginRequirement)req1).Holder == null );
Assert.That( ((PluginRequirement)req2).Holder == null );
passed = 0;
foreach( PluginRequirement o in reqs )
{
passed++;
}
Assert.That( passed == 0 );
}