public void SynchronizedListUnitTest()
{
SynchronizedList<string> list = new SynchronizedList<string>();
list.Add("one");
list.Add("two");
Assert.IsTrue(list.Count == 2);
foreach (string name in list)
{
Assert.IsTrue(list.Contains(name));
}
list.Remove("one");
Assert.IsTrue(list.Count == 1);
list.Insert(0, "one");
Assert.IsTrue(list.Count == 2);
Assert.IsTrue(list.Contains("one"));
Assert.IsTrue(list[0] == "one");
list.RemoveAt(0);
Assert.IsFalse(list.Contains("one"));
list.Clear();
Assert.IsTrue(list.Count == 0);
}
/// <summary>
/// Создать <see cref="DdeColumnsPicker"/>.
/// </summary>
public DdeColumnsPicker()
{
InitializeComponent();
lsvColumnsAll.ItemsSource = _columnsAll;
lsvColumnsSelected.ItemsSource = _columnsSelected;
ExcludeColumns = new SynchronizedList<string>();
}
public void TestRemoveAt()
{
SynchronizedList <int> list = new SynchronizedList <int>(new List <int>(), new IgnoreLocking());
list.Insert(0, 1);
list.Insert(0, 2);
list.Insert(0, 3);
list.RemoveAt(1);
list.RemoveAt(0);
Assert.AreEqual(1, list.Count);
Assert.AreEqual(1, list[0]);
}
public void SynchronizedListAddTest()
{
tlog.Debug(tag, $"SynchronizedListAddTest START");
try
{
var sl = new SynchronizedList <int>();
Assert.IsNotNull(sl, "null SynchronizedList");
sl.Add(1);
}
catch (Exception e)
{
Assert.Fail("Caught Exception" + e.ToString());
}
tlog.Debug(tag, $"SynchronizedListAddTest END");
}
public void TriggerConstructor()
{
tlog.Debug(tag, $"TriggerConstructor START");
try
{
var sl = new SynchronizedList <int>();
Assert.IsNotNull(sl, "null SynchronizedList");
Assert.IsInstanceOf <SynchronizedList <int> >(sl, "Should return SynchronizedList instance.");
}
catch (Exception e)
{
Assert.Fail("Caught Exception" + e.ToString());
}
tlog.Debug(tag, $"TriggerConstructor END");
}
public void TestIndexer()
{
SynchronizedList <int> list = new SynchronizedList <int>(new List <int>(), new IgnoreLocking());
list.Insert(0, 1);
list.Insert(0, 2);
list.Insert(0, 3);
Assert.AreEqual(3, list[0]);
Assert.AreEqual(2, list[1]);
Assert.AreEqual(1, list[2]);
list[2] ^= list[0];
list[0] ^= list[2];
list[2] ^= list[0];
Assert.AreEqual(1, list[0]);
Assert.AreEqual(2, list[1]);
Assert.AreEqual(3, list[2]);
}
public override void Entry(IModHelper helper)
{
IMultiplayerApi multiplayerApi = this.GetCoreApi().GetMultiplayerApi();
// Sync all the levels
this.SyncLevel(multiplayerApi, "combatLevel", () => Game1.player.combatLevel.Value, n => Game1.player.combatLevel.Value = n);
this.SyncLevel(multiplayerApi, "farmingLevel", () => Game1.player.farmingLevel.Value, n => Game1.player.farmingLevel.Value = n);
this.SyncLevel(multiplayerApi, "fishingLevel", () => Game1.player.fishingLevel.Value, n => Game1.player.fishingLevel.Value = n);
this.SyncLevel(multiplayerApi, "foragingLevel", () => Game1.player.foragingLevel.Value, n => Game1.player.foragingLevel.Value = n);
this.SyncLevel(multiplayerApi, "miningLevel", () => Game1.player.miningLevel.Value, n => Game1.player.miningLevel.Value = n);
this.SyncLevel(multiplayerApi, "luckLevel", () => Game1.player.luckLevel.Value, n => Game1.player.luckLevel.Value = n);
// Sync the exp
SynchronizedList <int> expList = new SynchronizedList <int>(n => n.MakeSynchronized());
multiplayerApi.Synchronize("expList", expList);
foreach (int exp in Game1.player.experiencePoints)
{
expList.Add(exp);
}
GameEvents.UpdateTick += (sender, args) => {
for (int i = 0; i < Game1.player.experiencePoints.Count; i++)
{
int cur = Game1.player.experiencePoints[i];
int synced = expList[i];
// Choose whichever is higher
if (cur < synced)
{
Game1.player.experiencePoints[i] = synced;
}
else if (synced < cur)
{
expList[i] = cur;
}
}
};
}
public void TestLock()
{
LockCounterFactory <SimpleReadWriteLocking> factory = new LockCounterFactory <SimpleReadWriteLocking>();
ILockStrategy lck = factory.Create();
SynchronizedList <int> list = new SynchronizedList <int>(lck);
Assert.IsTrue(ReferenceEquals(lck, list.Lock));
list.Add(42);
Assert.AreEqual(1, factory.TotalWriterCount);
Assert.AreEqual(0, factory.TotalReaderCount);
list[0] = 51;
Assert.AreEqual(2, factory.TotalWriterCount);
list.Insert(1, 52);
Assert.AreEqual(3, factory.TotalWriterCount);
list.RemoveAt(1);
Assert.AreEqual(4, factory.TotalWriterCount);
list.Remove(-1);
Assert.AreEqual(5, factory.TotalWriterCount);
Assert.AreEqual(51, list[0]);
Assert.AreEqual(1, factory.TotalReaderCount);
foreach (int i in list)
{
GC.KeepAlive(i);
}
Assert.AreEqual(2, factory.TotalReaderCount);
Assert.AreEqual(0, list.IndexOf(51));
Assert.AreEqual(3, factory.TotalReaderCount);
Assert.AreEqual(1, list.Count);
Assert.AreEqual(4, factory.TotalReaderCount);
}
public async Task TestSingleInstance_NotifyFirstInstance()
{
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
var applicationId = Guid.NewGuid();
using var singleInstance = new SingleInstance(applicationId);
Assert.True(singleInstance.StartApplication(), "Cannot start the instance");
// Be sure the server is ready
await Task.Delay(50);
var events = new SynchronizedList <SingleInstanceEventArgs>();
singleInstance.NewInstance += SingleInstance_NewInstance;
Assert.True(singleInstance.NotifyFirstInstance(new[] { "a", "b", "c" }), "Cannot notify first instance 1");
await Task.Delay(50);
Assert.True(singleInstance.NotifyFirstInstance(new[] { "123" }), "Cannot notify first instance 2");
while (!cts.Token.IsCancellationRequested && events.Count < 2)
{
await Task.Delay(50);
}
Assert.Equal(2, events.Count);
var orderedEvents = events.OrderBy(args => args.Arguments.Length).ToList();
Assert.Equal(new[] { "123" }, orderedEvents[0].Arguments);
Assert.Equal(new[] { "a", "b", "c" }, orderedEvents[1].Arguments);
void SingleInstance_NewInstance(object sender, SingleInstanceEventArgs e)
{
Assert.Equal(singleInstance, sender);
events.Add(e);
}
}
private static void ExecuteConcurrentlyInternal(params Action[] actions)
{
if (actions.Length == 0)
{
return;
}
var errors = new SynchronizedList <Exception>();
var numberOfActions = actions.Length;
var waitHandlers = new AutoResetEvent[numberOfActions];
for (var i = 0; i < numberOfActions; i++)
{
var action = actions[i];
var waitHandler = new AutoResetEvent(false);
waitHandlers[i] = waitHandler;
WaitCallback callback = state => {
try {
action();
} catch (Exception error) {
using (errors.EnterWriteScope()) {
errors.Add(error);
}
}
waitHandler.Set();
};
ThreadPool.QueueUserWorkItem(callback);
}
WaitHandle.WaitAll(waitHandlers);
if (errors.Count > 0)
{
throw new AggregateException(errors);
}
}
public AuctionHouse()
{
auctions = new SynchronizedDictionary<uint, Auction>(10000);
items = new SynchronizedList<uint>(10000);
}
public StrategyInfo()
{
_strategies = new SynchronizedList<StrategyContainer>();
_strategies.Added += s => s.ProcessStateChanged += StrategyProcessStateChanged;
_strategies.Removed += s => s.ProcessStateChanged -= StrategyProcessStateChanged;
}
public SynchronizedList(SynchronizedList <T> queue)
{
m_List = new List <T>(queue.m_List);
m_lock = new object();
}
public static void OtherExample()
{
ICollection <string> collection = new SynchronizedList <string>(new List <string>());
}
/// <summary>
/// Listens for an incoming client connection and starts a new thread for client communication when a client connects.
/// </summary>
private void Listen()
{
SynchronizedList<Thread> threadList = new SynchronizedList<Thread>();
listener.Start();
listen = true;
while (listen)
{
if (listener.Pending())
{
TcpClient client = listener.AcceptTcpClient();
clientQueue.Enqueue(client);
Thread thread = new Thread(new ThreadStart(ServiceClient));
thread.IsBackground = true;
thread.Start();
threadList.Add(thread);
}
else
{
Thread.Sleep(TimeSpan.Zero);
}
}
listener.Stop();
foreach (Thread thread in threadList)
{
thread.Join();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CodePanel"/>.
/// </summary>
public CodePanel()
{
InitializeComponent();
_projectAssembly = new CSharpProjectAssembly("StudioStrategy");
_projectAssembly.AssemblyReferences.AddMsCorLib();
var language = new CSharpSyntaxLanguage();
language.RegisterProjectAssembly(_projectAssembly);
CodeEditor.Document.Language = language;
_errorsSource = new ObservableCollection<CompileResultItem>();
ErrorsGrid.ItemsSource = _errorsSource;
var references = new SynchronizedList<CodeReference>();
references.Added += r => _references.SafeAdd(r, r1 =>
{
IProjectAssemblyReference asmRef = null;
try
{
asmRef = _projectAssembly.AssemblyReferences.AddFrom(r1.Location);
}
catch (Exception ex)
{
ex.LogError();
}
return asmRef;
});
references.Removed += r =>
{
var item = _projectAssembly
.AssemblyReferences
.FirstOrDefault(p =>
{
var assm = p.Assembly as IBinaryAssembly;
if (assm == null)
return false;
return assm.Location == r.Location;
});
if (item != null)
_projectAssembly.AssemblyReferences.Remove(item);
};
references.Cleared += () =>
{
_projectAssembly.AssemblyReferences.Clear();
_projectAssembly.AssemblyReferences.AddMsCorLib();
};
References = references;
}
public ExecuteBackgroundCommandOnCollection(ILogger logDirector)
{
this.logDirector = logDirector;
this.Commands = new SynchronizedList<IExecuteBackgroundCommand>();
}
public AuctionHouse()
{
auctions = new SynchronizedDictionary <uint, Auction>(10000);
items = new SynchronizedList <uint>(10000);
}
private GazeManager()
{
HeartbeatMillis = 3000; //default value
gazeListeners = new SynchronizedList<IGazeListener>();
calibrationResultListeners = new SynchronizedList<ICalibrationResultListener>();
trackerStateListeners = new SynchronizedList<ITrackerStateListener>();
connectionStateListeners = new SynchronizedList<IConnectionStateListener>();
gazeQueue = new SingleFrameBlockingQueue<GazeData>();
}
/// <summary>
/// Initializes a new instance of the <see cref="CodePanel"/>.
/// </summary>
public CodePanel()
{
InitializeComponent();
_projectAssembly = new CSharpProjectAssembly("StudioStrategy");
_projectAssembly.AssemblyReferences.AddMsCorLib();
var language = new CSharpSyntaxLanguage();
language.RegisterProjectAssembly(_projectAssembly);
CodeEditor.Document.Language = language;
_errorsSource = new ObservableCollection <CompileResultItem>();
ErrorsGrid.ItemsSource = _errorsSource;
var references = new SynchronizedList <CodeReference>();
references.Added += r => _references.SafeAdd(r, r1 =>
{
IProjectAssemblyReference asmRef = null;
try
{
asmRef = _projectAssembly.AssemblyReferences.AddFrom(r1.Location);
}
catch (Exception ex)
{
ex.LogError();
}
return(asmRef);
});
references.Removed += r =>
{
var item = _projectAssembly
.AssemblyReferences
.FirstOrDefault(p =>
{
var assm = p.Assembly as IBinaryAssembly;
if (assm == null)
{
return(false);
}
return(assm.Location == r.Location);
});
if (item != null)
{
_projectAssembly.AssemblyReferences.Remove(item);
}
};
references.Cleared += () =>
{
_projectAssembly.AssemblyReferences.Clear();
_projectAssembly.AssemblyReferences.AddMsCorLib();
};
References = references;
}
public LoggerContainer()
{
this.Loggers = new SynchronizedList<ILogger>();
}
private void ScheduleBackgroundProcess(SynchronizedList <IPsiSourceFile> toDelete, SynchronizedList <IPsiSourceFile> toProcess,
ConcurrentDictionary <IPsiSourceFile, (long, Dictionary <IDeferredCache, object>)> calculatedData)
static Log()
{
Listeners = new SynchronizedList <LogListener>();
}
public StrategyInfo()
{
_strategies = new SynchronizedList <StrategyContainer>();
_strategies.Added += s => s.ProcessStateChanged += StrategyProcessStateChanged;
_strategies.Removed += s => s.ProcessStateChanged -= StrategyProcessStateChanged;
}
//-----------------------------------------------------------------------
/**
* Returns a synchronized list backed by the given list.
* <p>
* You must manually synchronize on the returned buffer's iterator to
* avoid non-deterministic behavior:
*
* <pre>
* List list = ListUtils.synchronizedList(myList);
* synchronized (list) {
* Iterator i = list.iterator();
* while (i.hasNext()) {
* process (i.next());
* }
* }
* </pre>
*
* This method uses the implementation in the decorators subpackage.
*
* @param list the list to synchronize, must not be null
* @return a synchronized list backed by the given list
* @throws IllegalArgumentException if the list is null
*/
public static java.util.List <Object> synchronizedList(java.util.List <Object> list)
{
return(SynchronizedList.decorate(list));
}
public override void Run()
{
try
{
IDictionary <string, int?> values = new Dictionary <string, int?>();
IList <string> allIDs = new SynchronizedList <string>();
StartingGun.Wait();
for (int iter = 0; iter < Iters; iter++)
{
// Add/update a document
Document doc = new Document();
// Threads must not update the same id at the
// same time:
if (ThreadRandom.NextDouble() <= AddChance)
{
string id = string.Format(CultureInfo.InvariantCulture, "{0}_{1:X4}", ThreadID, ThreadRandom.Next(IdCount));
int field = ThreadRandom.Next(int.MaxValue);
doc.Add(new StringField("id", id, Field.Store.YES));
doc.Add(new Int32Field("field", (int)field, Field.Store.YES));
w.UpdateDocument(new Term("id", id), doc);
Rt.Add(id, field);
if (!values.ContainsKey(id))//Key didn't exist before
{
allIDs.Add(id);
}
values[id] = field;
}
if (allIDs.Count > 0 && ThreadRandom.NextDouble() <= DeleteChance)
{
string randomID = allIDs[ThreadRandom.Next(allIDs.Count)];
w.DeleteDocuments(new Term("id", randomID));
Rt.Delete(randomID);
values[randomID] = Missing;
}
if (ThreadRandom.NextDouble() <= ReopenChance || Rt.Count > 10000)
{
//System.out.println("refresh @ " + rt.Size());
Mgr.MaybeRefresh();
if (VERBOSE)
{
IndexSearcher s = Mgr.Acquire();
try
{
Console.WriteLine("TEST: reopen " + s);
}
finally
{
Mgr.Release(s);
}
Console.WriteLine("TEST: " + values.Count + " values");
}
}
if (ThreadRandom.Next(10) == 7)
{
Assert.AreEqual(null, Rt.Get("foo"));
}
if (allIDs.Count > 0)
{
string randomID = allIDs[ThreadRandom.Next(allIDs.Count)];
int? expected = values[randomID];
if (expected == Missing)
{
expected = null;
}
Assert.AreEqual(expected, Rt.Get(randomID), "id=" + randomID);
}
}
}
catch (Exception t)
{
throw new Exception(t.Message, t);
}
}
public RunCommandOnCollection(ILogger logDirector)
{
this.logDirector = logDirector;
this.Commands = new SynchronizedList<IRunCommand>();
}
