public void JobShouldRunIfRunnerThreadIsRunning()
{
string name = MethodBase.GetCurrentMethod().Name;
JobConductorService fm = GetTestJobConductor(name);
fm.StopJobRunnerThread();
fm.JobQueue.Clear();
fm.StartJobRunnerThread();
JobConf conf = fm.CreateJob(name);
TestWorker.ValueToCheck = false;
TestWorker worker = new TestWorker();
conf.AddWorker(worker);
Expect.IsFalse(TestWorker.ValueToCheck);
bool? finished = false;
AutoResetEvent signal = new AutoResetEvent(false);
fm.WorkerFinished += (o, a) =>
{
Expect.IsTrue(TestWorker.ValueToCheck);
finished = true;
signal.Set();
};
fm.EnqueueJob(conf);
signal.WaitOne(10000);
Expect.IsTrue(finished == true);
}
public async Task DurationWork_ShallRunAllMessagesTest()
{
var duration = TimeSpan.FromSeconds(1);
var stopWatch = Stopwatch.StartNew();
var service = new TestWorker
{
SleepDurationMilliseconds = 100
};
var logger = new LoggerFactory().CreateLogger <Runner>();
var threadResult = new ThreadResult();
var worker = new Runner(service, threadResult, logger);
var messageA = new HttpRequestMessage(HttpMethod.Get, "/a");
var messageB = new HttpRequestMessage(HttpMethod.Get, "/b");
var resetEvent = new ManualResetEventSlim(false);
var cts = new CancellationTokenSource(2000);
var cancellationToken = cts.Token;
await worker.DurationWork(new[] { messageA, messageB }, duration, stopWatch, resetEvent, cancellationToken);
var results = threadResult.Results;
Assert.Equal(2, results.Count);
}
public static void TestMultipleConnectionToMirroredServer()
{
string mirroringStateDesc;
string failoverPartnerName;
bool isMirroring = GetMirroringInfo(DataTestUtility.TcpConnStr, out mirroringStateDesc, out failoverPartnerName);
bool isSynchronized = "SYNCHRONIZED".Equals(mirroringStateDesc, StringComparison.InvariantCultureIgnoreCase);
if (isMirroring && isSynchronized && !string.IsNullOrEmpty(failoverPartnerName))
{
SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(DataTestUtility.TcpConnStr);
builder.ConnectTimeout = 0;
TestWorker worker = new TestWorker(builder.ConnectionString);
Thread childThread = new Thread(() => worker.TestMultipleConnection());
childThread.Start();
if (workerCompletedEvent.WaitOne(10000))
{
childThread.Join();
}
else
{
// currently Thread.Abort() throws PlatformNotSupportedException in CoreFx.
childThread.Interrupt();
throw new Exception("SqlConnection could not open and close successfully in timely manner. Possibly connection hangs.");
}
}
}
private void btnOQuery_Click(object sender, EventArgs e)
{
if (TestWorker.IsBusy == false)
{
TestWorker.RunWorkerAsync();
}
}
public void DurationWork_ShallTimeOutTest()
{
var duration = TimeSpan.FromSeconds(2);
var stopWatch = new Stopwatch();
var service = new TestWorker
{
SleepDurationMilliseconds = 800
};
var logger = new LoggerFactory().CreateLogger <Runner>();
var threadResult = new ThreadResult();
var worker = new Runner(service, threadResult, logger);
var messageA = new HttpRequestMessage(HttpMethod.Get, "/a");
var messageB = new HttpRequestMessage(HttpMethod.Get, "/b");
var resetEvent = new ManualResetEventSlim(false);
var cts = new CancellationTokenSource(100);
var cancellationToken = cts.Token;
Assert.ThrowsAsync <TaskCanceledException>(async() =>
{
await worker.DurationWork(new[] { messageA, messageB }, duration, stopWatch, resetEvent, cancellationToken);
});
}
public void TestThrowExceptionInDoWork()
{
var bw = new TestWorker();
bw.DoWork += DoWorkWithException;
bw.RunWorkerAsync("Exception");
}
public async Task <bool> DeleteTest(ObjectId testId)
{
var response = await TestWorker.Delete(testId);
await _redisCache.Del($"Test:{testId}");
return(response);
}
public JavaUtils(ModulrConfig config, TestWorker worker)
{
ModulrJail.Config = config;
ModulrJail.WebSocket = worker;
_config = config;
_rng = new Random();
Clean();
}
public async Task <long> DeleteTestsByRoomId(ObjectId roomId)
{
(await TestWorker.GetTestsByRoomId(roomId))
.Select(async test =>
await _redisCache.Del($"Test:{test.Id}"));
return(await TestWorker.DeleteTestsByRoomId(roomId));
}
private void TestWorker_DoWork(object sender, DoWorkEventArgs e)
{
try
{
TestWorker.ReportProgress(0, "Query Start");
StockQuery query = new StockQuery();
query.QueryOTC();
query.QueryOTCWarrant(DateTime.Now);
TestWorker.ReportProgress(0, "Query End");
}
catch (Exception ex)
{
TestWorker.ReportProgress(0, ex.Message);
}
}
private void StartBtn_Click(object sender, EventArgs e)
{
if (StartBtn.Text == "Start" && !TestWorker.IsBusy)
{
TestWorker.RunWorkerAsync();
StartBtn.Text = "Stop";
}
else if (TestWorker.IsBusy)
{
Character.Navi.Reset();
TestWorker.CancelAsync();
StartBtn.Text = "Start";
Character.Navi.Reset();
}
}
public IActionResult CopyExample([FromBody] TestWorkerQueryDTO testWorkerDTO)
{
Console.WriteLine($"dto=====>{testWorkerDTO.ToJson()}");
Console.WriteLine($"复制实例");
var model = WAutoMapper <TestWorkerQueryDTO, TestWorker> .Map(testWorkerDTO);
Console.WriteLine($"model====>{model.ToJson()}");
Console.WriteLine($"正常实例");
var model2 = new TestWorker
{
id = (int)testWorkerDTO.id,
createTime = testWorkerDTO.createTime,
name = testWorkerDTO.name,
age = testWorkerDTO.age
};
Console.WriteLine($"model====>{model2.ToJson()}");
return(ApiResult(model));
}
public void CreateWorkerThreads_CountWorkTest()
{
var service = new TestWorker
{
SleepDurationMilliseconds = 100
};
var logger = new LoggerFactory().CreateLogger <Runner>();
var threadResult = new ThreadResult();
var worker = new Runner(service, threadResult, logger);
var messageA = new HttpRequestMessage(HttpMethod.Get, "/a");
var messageB = new HttpRequestMessage(HttpMethod.Get, "/b");
var cts = new CancellationTokenSource(1000);
var cancellationToken = cts.Token;
worker.CreateWorkerThreads(1, TimeSpan.FromSeconds(0), 1, 0, new[] { messageA, messageB }, cancellationToken);
var results = threadResult.Results;
Assert.Equal(2, results.Count);
}
public override void Run()
{
// This is a sample worker implementation. Replace with your logic.
Trace.TraceInformation("TestRequestProcessor entry point called", "Information");
string requestQueueName = CloudConfigurationManager.GetSetting("ServiceRequestQueue");
string storageConnectionString = CloudConfigurationManager.GetSetting("StorageConnectionString");
int messagesPerRequest = Int32.Parse(CloudConfigurationManager.GetSetting("MessagesPerRequest"));
var requestTimeout = TimeSpan.FromSeconds(15); // if the request cannot be completed after this long, let someone else try
var testWorker = new TestWorker(storageConnectionString, requestQueueName, requestTimeout, messagesPerRequest);
try
{
Task processRequests = testWorker.ProcessRequestsAsync();
processRequests.Wait(); // should never return
}
catch (Exception ex)
{
TestRecorder.LogException(storageConnectionString, RoleEnvironment.CurrentRoleInstance.Id, ex);
throw;
}
}
public async Task CountWork_ShallRunOneMessagesTest()
{
var service = new TestWorker
{
SleepDurationMilliseconds = 100
};
var logger = new LoggerFactory().CreateLogger <Runner>();
var threadResult = new ThreadResult();
var worker = new Runner(service, threadResult, logger);
var messageA = new HttpRequestMessage(HttpMethod.Get, "/a");
var messageB = new HttpRequestMessage(HttpMethod.Get, "/b");
var resetEvent = new ManualResetEventSlim(false);
var cts1 = new CancellationTokenSource(100);
var cancellationToken = cts1.Token;
await worker.CountWork(new[] { messageA, messageB }, 1, resetEvent, cancellationToken);
var results = threadResult.Results;
Assert.Equal(1, results.Count);
}
private void TestWorker_DoWork(object sender, DoWorkEventArgs e)
{
while (!TestWorker.CancellationPending)
{
var start2 = new position_t {
X = Character.Api.Player.X, Y = Character.Api.Player.Y, Z = Character.Api.Player.Z
};
var mob = Character.Api.Entity.GetEntity(Character.Target.FindBestTarget());
var end = new position_t {
X = mob.X, Z = mob.Z
};
var mobid = Character.Target.FindBestTarget();
if (FFxiNAV.waypoints.Count > 0)
{
foreach (var wp in FFxiNAV.waypoints)
{
dist = Character.Navi.DistanceTo(wp);
while (dist > 6 && !TestWorker.CancellationPending && mob.Distance > 6)
{
var start3 = new position_t {
X = Character.Api.Player.X, Z = Character.Api.Player.Z
};
dist = Character.Navi.DistanceTo(wp);
Character.Logger.AddDebugText(rtbDebug, string.Format(@"start x {0} target x {1} distance {2}", start3.X.ToString(), wp.X.ToString(), dist.ToString()));
Character.Navi.GoTo(wp.X, wp.Z);
Thread.Sleep(200);
}
if (mob.Distance < 5 && !TestWorker.CancellationPending)
{
Character.Navi.FaceHeading(end);
Character.Navi.Reset();
Character.Target.TargetNpc(mobid);
Thread.Sleep(100);
Character.Api.ThirdParty.SendString("/attack <t>");
}
}
if (mob.Distance > 2.5 && FFxiNAV.waypoints.Count > 0 && !TestWorker.CancellationPending)
{
var end1 = new position_t {
X = mob.X, Z = mob.Z
};
var mobid1 = Character.Target.FindBestTarget();
Character.Navi.FaceHeading(end1);
Character.Navi.MoveForwardTowardsPosition(end1, true);
Character.Navi.FaceHeading(end1);
Character.Navi.Reset();
Character.Target.TargetNpc(mobid1);
Thread.Sleep(100);
Character.Api.ThirdParty.SendString("/attack <t>");
}
if (mob.Distance < 3)
{
FFxiNAV.waypoints.Clear();
Character.Navi.Reset();
mob = null;
TestWorker.CancelAsync();
Character.Navi.Reset();
}
}
Thread.Sleep(200);
}
}
public void TestThrowExceptionInDoWork()
{
var bw = new TestWorker();
bw.DoWork += DoWorkWithException;
bw.RunWorkerAsync("Exception");
}
public async Task <bool> SetProperties(ObjectId testId, Dictionary <string, object> properties)
{
await _redisCache.Del($"Test:{testId}");
return(await TestWorker.SetProperties(testId, properties));
}
public async Task <bool> SetProperty(ObjectId testId, string propertyName, object newPropertyValue)
{
await _redisCache.Del($"Test:{testId}");
return(await TestWorker.SetProperty(testId, propertyName, newPropertyValue));
}
public async Task ReplaceTest(TestsDB_TestDTO updatedTest)
{
await TestWorker.Replace(updatedTest);
await _redisCache.Del($"Test:{updatedTest.Id}");
}
public async Task <ObjectId> InsertTest(TestsDB_TestDTO newTest) => await TestWorker.InsertTest(newTest);
public async Task <TestsDB_TestDTO[]> GetTestsByRoomId(ObjectId roomId) => await TestWorker.GetTestsByRoomId(roomId);
public async Task <TestsDB_TestDTO> GetTestById(ObjectId testId) =>
//await _redisCache.Get($"Test:{testId}", async () => await TestWorker.GetTestById(testId));
await TestWorker.GetTestById(testId);
