MiniContext(string name)
{
ServiceContainer = new SimpleServiceContainer();
ServiceContainer.Add(RequirementLayerSerializer.Instance);
ServiceContainer.Add(SimpleTypeFinder.Default);
ConfigContainer = SharedDictionary.Create(ServiceContainer);
ConfigManager = ConfigurationManager.Create(ConfigContainer).ConfigManager;
}
void EntryInit()
{
var counter = SharedDictionary.Create <int, string>(this.Id.Runtime);
counter.TryAdd(1, "M");
var v = counter[2];
this.Assert(v == "M");
}
private void InitOnEntry()
{
var counter = SharedDictionary.Create <int, string>(this.Id.Runtime);
counter.TryAdd(1, "M");
// Key not present; will throw an exception.
var v = counter[2];
}
public void TestSharedDictionary6()
{
this.Test(r =>
{
var counter = SharedDictionary.Create <int, string>(r);
r.CreateActor(typeof(M5), new E2(counter, false));
},
configuration: Configuration.Create().WithTestingIterations(50));
}
public void TestMockSharedDictionary7()
{
var config = Configuration.Create().WithNumberOfIterations(50);
var test = new Action <PSharpRuntime>((r) => {
var counter = SharedDictionary.Create <int, string>(r);
r.CreateMachine(typeof(M6), new E1(counter));
});
base.AssertFailed(config, test, "Detected an assertion failure.");
}
public void TestMockSharedDictionary6()
{
var config = Configuration.Create().WithNumberOfIterations(50);
var test = new Action <PSharpRuntime>((r) => {
var counter = SharedDictionary.Create <int, string>(r);
r.CreateMachine(typeof(M5), new E2(counter, false));
});
base.AssertSucceeded(config, test);
}
MiniContext(string name)
{
ServiceContainer = new SimpleServiceContainer();
ContextObject = new object();
ConfigContainer = SharedDictionary.Create(ServiceContainer);
ConfigManager = ConfigurationManager.Create(ConfigContainer).ConfigManager;
PluginRunner = new PluginRunner(ServiceContainer, ConfigManager);
PluginRunner.Initialize(ContextObject);
ServiceContainer.Add <IConfigContainer>(ConfigContainer);
}
private void InitOnEntry()
{
var counter = SharedDictionary.Create <int, string>(this.Id.Runtime);
this.CreateActor(typeof(N1), new E1(counter));
counter.TryAdd(1, "M");
var v = counter[1];
this.Assert(v == "M", "Reached test assertion.");
}
public void TestSharedDictionary7()
{
this.TestWithError(r =>
{
var counter = SharedDictionary.Create <int, string>(r);
r.CreateActor(typeof(M6), new E1(counter));
},
configuration: Configuration.Create().WithTestingIterations(50),
expectedError: "Reached test assertion.",
replay: true);
}
void InitOnEntry()
{
var counter = SharedDictionary.Create <int, string>(this.Id.Runtime);
this.CreateMachine(typeof(N1), new E1(counter));
counter.TryAdd(1, "M");
var v = counter[1];
this.Assert(v == "M");
}
private void InitOnEntry()
{
var counter = SharedDictionary.Create <int, string>(this.Id.Runtime);
this.CreateMachine(typeof(N4), new E1(counter));
counter.TryAdd(1, "M");
var b = counter.TryRemove(1, out string v);
this.Assert(b == false || v == "M");
this.Assert(counter.Count == 0);
}
void EntryInit()
{
var counter = SharedDictionary.Create <int, string>(this.Id.Runtime);
this.CreateMachine(typeof(N), new E(counter));
counter.TryAdd(1, "M");
var v = counter[1];
var c = counter.Count;
this.Assert(c == 1);
}
private void InitOnEntry()
{
var counter = SharedDictionary.Create <int, string>(this.Id.Runtime);
this.CreateActor(typeof(N3), new E1(counter));
counter.TryAdd(1, "M");
_ = counter[1];
var c = counter.Count;
this.Assert(c == 1);
}
protected override void OnLinkedTo(RuntimeHost runtimeHost, params object[] args)
{
if (args == null || args.Length == 0)
{
m_dic = SharedDictionary.Create <TKey, TValue>(runtimeHost.Runtime);
}
else if (args.Length == 1 && args[0] is IEqualityComparer <TKey> comparer)
{
m_dic = SharedDictionary.Create <TKey, TValue>(comparer, runtimeHost.Runtime);
}
else
{
throw new ArgumentOutOfRangeException(nameof(args), "The value needs to translate in null, empty or the array that has just one element as IEqualityComparer<TKey>.");
}
}
public SharedDictionaryTester(string testName, string path, object o, INamedVersionedUniqueId uid1, INamedVersionedUniqueId uid2, Action <ISharedDictionary, object, INamedVersionedUniqueId> f)
{
_errors = new List <ReadElementObjectInfo>();
_testName = testName;
_path = path;
_seed = Environment.TickCount;
_o = o;
_uid1 = uid1;
_uid2 = uid2;
_dic = SharedDictionary.Create(null);
_seed2 = GenerateRandomProperties(_dic, _o, _uid1, 10, _seed);
f(_dic, _o, _uid1);
_seed3 = GenerateRandomProperties(_dic, _o, _uid1, 10, _seed2);
GenerateRandomProperties(_dic, _o, _uid2, 20, _seed3);
}
public void WriteReadUserConfig()
{
string path = Path.Combine(TestFolder, "UserConfig.xml");
Guid id = new Guid("{6AFBAE01-5CD1-4EDE-BB56-4590C5A253DF}");
// Write ----------------------------------------------------------
{
ISharedDictionary dic = SharedDictionary.Create(null);
IConfigManagerExtended config = ConfigurationManager.Create(dic);
Assert.That(config, Is.Not.Null);
Assert.That(config.HostUserConfig, Is.Not.Null);
Assert.That(config.ConfigManager.UserConfiguration, Is.Not.Null);
config.HostUserConfig["key1"] = "value1";
config.HostUserConfig["key2"] = "value2";
config.HostUserConfig["key3"] = "value3";
config.ConfigManager.UserConfiguration.PluginsStatus.SetStatus(id, ConfigPluginStatus.AutomaticStart);
Assert.That(config.IsUserConfigDirty);
Assert.That(config.IsSystemConfigDirty, Is.False);
using (Stream wrt = new FileStream(path, FileMode.Create))
using (IStructuredWriter sw = SimpleStructuredWriter.CreateWriter(wrt, null))
{
config.SaveUserConfig(sw);
}
}
// Read ------------------------------------------------------------
{
ISimpleServiceContainer container = new SimpleServiceContainer();
ISharedDictionary dic = SharedDictionary.Create(container);
IConfigManagerExtended config = ConfigurationManager.Create(dic);
using (Stream str = new FileStream(path, FileMode.Open))
using (IStructuredReader sr = SimpleStructuredReader.CreateReader(str, container))
{
config.LoadUserConfig(sr);
}
Assert.That(config.HostUserConfig["key1"], Is.EqualTo("value1"));
Assert.That(config.HostUserConfig["key2"], Is.EqualTo("value2"));
Assert.That(config.HostUserConfig["key3"], Is.EqualTo("value3"));
Assert.That(config.ConfigManager.UserConfiguration.PluginsStatus.GetStatus(id, ConfigPluginStatus.Disabled) == ConfigPluginStatus.AutomaticStart);
}
}
public void TestDictionarySuccess()
{
var runtime = PSharpRuntime.Create();
var counter = SharedDictionary.Create <int, string>(runtime);
var tcs1 = new TaskCompletionSource <bool>();
var failed = false;
runtime.OnFailure += delegate
{
failed = true;
tcs1.SetResult(true);
};
var m1 = runtime.CreateMachine(typeof(M), new E(counter, tcs1));
Task.WaitAll(tcs1.Task);
Assert.False(failed);
}
public void TestProductionSharedDictionary5()
{
var runtime = RuntimeFactory.Create();
var counter = SharedDictionary.Create <int, string>(runtime);
var tcs1 = new TaskCompletionSource <bool>();
var failed = false;
runtime.OnFailure += (ex) =>
{
failed = true;
tcs1.SetResult(true);
};
var m1 = runtime.CreateActor(typeof(M5), new E(counter, tcs1));
Task.WaitAll(tcs1.Task);
Assert.False(failed);
}
public void WriteReadSystemConfig()
{
string path = Path.Combine(TestFolder, "SystemConfig.xml");
// Write ----------------------------------------------------------
{
ISharedDictionary dic = SharedDictionary.Create(null);
IConfigManagerExtended config = ConfigurationManager.Create(dic);
Assert.That(config.ConfigManager.SystemConfiguration != null);
config.HostSystemConfig["key1"] = "value1";
config.HostSystemConfig["key2"] = "value2";
config.HostSystemConfig["key3"] = "value3";
config.HostSystemConfig["{12A9FCC0-ECDC-4049-8DBF-8961E49A9EDE}"] = true;
Assert.That(config.IsSystemConfigDirty);
Assert.That(config.IsUserConfigDirty, Is.False);
using (Stream wrt = new FileStream(path, FileMode.Create))
using (IStructuredWriter sw = SimpleStructuredWriter.CreateWriter(wrt, null))
{
config.SaveSystemConfig(sw);
}
}
TestBase.DumpFileToConsole(path);
// Read ------------------------------------------------------------
{
ISharedDictionary dic = SharedDictionary.Create(null);
IConfigManagerExtended config = new ConfigManagerImpl(dic);
using (Stream str = new FileStream(path, FileMode.Open))
using (IStructuredReader sr = SimpleStructuredReader.CreateReader(str, null))
{
config.LoadSystemConfig(sr);
}
Assert.That(config.HostSystemConfig["key1"], Is.EqualTo("value1"));
Assert.That(config.HostSystemConfig["key2"], Is.EqualTo("value2"));
Assert.That(config.HostSystemConfig["key3"], Is.EqualTo("value3"));
Assert.That(config.HostSystemConfig["{12A9FCC0-ECDC-4049-8DBF-8961E49A9EDE}"], Is.EqualTo(true));
}
}
public void ImportReloadedSkippedFragments()
{
INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0];
INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1];
string path = TestBase.GetTestFilePath("SharedDic", "ImportReloadedSkippedFragments");
#region Creates actual fragments
// Creates a dummy dictionnary and writes it.
SharedDictionaryImpl dic = CreateDummySharedDic(this, uid1, uid2);
SharedDicTestContext.Write("Test", path, dic, this);
// Creates a second dictionnary to load previous data (with skippedFragments).
IList <ReadElementObjectInfo> errors;
SharedDictionaryImpl dicFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, out errors);
Assert.IsTrue(new FileInfo(path).Length > 0, "File must exist and be not empty.");
Assert.That(errors.Count, Is.EqualTo(0));
Assert.That(dicFrag.GetSkippedFragments(this).Count == 2);
Assert.That(dicFrag[this, uid1, "key1"], Is.Null);
Assert.That(dicFrag[this, uid2, "key2"], Is.Null);
#endregion
ISharedDictionary dic2 = SharedDictionary.Create(SharedDicTestContext.ServiceProvider);
dic2[this, uid1, "key1"] = "value1";
dic2[this, uid1, "key2"] = "value2";
Assert.That(dic2[this, uid2, "key1"], Is.Null);
Assert.That(dic2[this, uid2, "key2"], Is.Null);
dic2.Ensure(uid2);
SharedDictionaryImpl implDic2 = (SharedDictionaryImpl)dic2;
implDic2.ImportFragments(dicFrag.Fragments, MergeMode.None);
Assert.That(implDic2.GetSkippedFragments(this) == null);
Assert.That(dic2[this, uid2, "key1"], Is.EqualTo("value1"));
Assert.That(dic2[this, uid2, "key2"], Is.EqualTo("value2"));
}
public static ISharedDictionary Read(string testName, string path, object o, Action <ISharedDictionary> beforeRead, out IList <ReadElementObjectInfo> errors)
{
ISharedDictionary dicRead = SharedDictionary.Create(ServiceProvider);
if (beforeRead != null)
{
beforeRead(dicRead);
}
using (Stream str = new FileStream(path, FileMode.Open))
{
using (IStructuredReader sr = SimpleStructuredReader.CreateReader(str, ServiceProvider))
{
using (ISharedDictionaryReader r = dicRead.RegisterReader(sr, MergeMode.None))
{
r.ReadPluginsDataElement(testName, o);
errors = r.ErrorCollector;
}
}
}
return(dicRead);
}
private Context(bool proxified)
{
_serviceContainer = new ContextServiceContainer(this);
_dic = SharedDictionary.Create(_serviceContainer);
_configManager = ConfigurationManager.Create(_dic);
_reqLayer = new RequirementLayer("Context");
_pluginRunner = new PluginRunner(_serviceContainer, _configManager.ConfigManager);
_serviceContainer.Add(RequirementLayerSerializer.Instance);
_serviceContainer.Add(SimpleTypeFinder.Default);
if (proxified)
{
_proxifiedContext = (IContext)_pluginRunner.ServiceHost.InjectExternalService(typeof(IContext), this);
}
else
{
_proxifiedContext = this;
_serviceContainer.Add <IContext>(this);
}
_pluginRunner.Initialize(_proxifiedContext);
}
public void TestDictionaryCount()
{
var runtime = PSharpRuntime.Create();
var dictionary = SharedDictionary.Create <int, string>(runtime);
var counter = SharedCounter.Create(runtime);
var tcs1 = new TaskCompletionSource <bool>();
var tcs2 = new TaskCompletionSource <bool>();
var failed = false;
runtime.OnFailure += delegate
{
failed = true;
tcs1.TrySetResult(true);
tcs2.TrySetResult(true);
};
var m1 = runtime.CreateMachine(typeof(M), new E(dictionary, counter, tcs1));
var m2 = runtime.CreateMachine(typeof(N), new E(dictionary, counter, tcs2));
Task.WaitAll(tcs1.Task, tcs2.Task);
Assert.False(failed);
Assert.True(counter.GetValue() == T);
}
public void TestProductionSharedObjects()
{
var runtime = RuntimeFactory.Create();
var dictionary = SharedDictionary.Create <int, string>(runtime);
var counter = SharedCounter.Create(runtime);
var tcs1 = new TaskCompletionSource <bool>();
var tcs2 = new TaskCompletionSource <bool>();
var failed = false;
runtime.OnFailure += (ex) =>
{
failed = true;
tcs1.TrySetResult(true);
tcs2.TrySetResult(true);
};
var m1 = runtime.CreateActor(typeof(M), new E(dictionary, counter, tcs1));
var m2 = runtime.CreateActor(typeof(N), new E(dictionary, counter, tcs2));
Task.WaitAll(tcs1.Task, tcs2.Task);
Assert.False(failed);
Assert.True(counter.GetValue() is 100);
}