public async System.Threading.Tasks.Task TestFetchAsync()
{
SayingsAbstractModel m = new MockedRemoteModel();
//Now how the following "captures m"
Func <Task> atest = async() =>
{
(bool success, string ErrorString) = await m.NextSaying();
Assert.IsTrue(success, "NextSaying failed");
Assert.IsTrue(ErrorString.Equals("OK"));
Assert.IsTrue(m.CurrentSaying.Equals(Sayings[0]));
(success, ErrorString) = await m.NextSaying();
Assert.IsTrue(success, "NextSaying failed");
Assert.IsTrue(ErrorString.Equals("OK"));
Assert.IsTrue(m.CurrentSaying.Equals(Sayings[1]));
};
await atest();
//Change m
m = new RemoteModel();
//Rerun tests
await atest();
}
public new bool Init()
{
if (base.Init() == false)
{
Log.Error("[BattleServer] Server Init Error");
return(false);
}
if (Net.Instance.Init() == false)
{
Log.Error("[BattleServer] Net Init Error");
return(false);
}
ErrorString err = StaticDataMgr.Instance.LoadAllCfg("../../config/binary");
if (err != null)
{
Log.Error("[BattleServer] StaticDataMgr LoadAllCfg Error");
return(false);
}
GlobalDef.GSSServerSessionMgr.Init(new ServerMgr());
GlobalDef.GServiceDiscoveryClient.Init(GlobalDef.GServerCfg.SDConnectIp, GlobalDef.GServerCfg.SDConnectPort, GlobalDef.GServer.GetServerID(), GlobalDef.GServer.GetToken());
Log.Info("[BattleServer] Init Ok");
return(true);
}
public string Post(StudentViewModel studentViewModel)
{
if (!ModelState.IsValid)
{
string errorMsg = string.Empty;
foreach (var onePire in ModelState)
{
var state = onePire.Value;
errorMsg += ErrorString.CollectError(state.Errors.Select(r => r.ErrorMessage));
}
return(errorMsg);
}
_service.Register(studentViewModel);
#region
/*RegisterStudentCommand registerStudentCommand =
* new RegisterStudentCommand(studentViewModel.Name,
* studentViewModel.Email, studentViewModel.BirthDate,
* studentViewModel.Phone);
* if (!registerStudentCommand.IsValid())
* {
* return ErrorString.CollectError(registerStudentCommand.ValidationResult.Errors);
* }*/
if (_notifications.HasNotifications())
{
return(ErrorString.CollectError(_notifications.GetNotifications()));
}
#endregion
return("success");
}
private string FormatErrorText(BBSError error, string boardKey, string name, string mail, string body, string hostAddress)
{
return(ErrorString.Replace("{{errorText}}", error.ErrorMessage + $" (Error Code: {error.ErrorCode})")
.Replace("{{hostAddress}}", hostAddress)
.Replace("{{name}}", name)
.Replace("{{mail}}", mail)
.Replace("{{body}}", body)
.Replace("{{boardKey}}", boardKey));
}
// checkErrMessageContent checks if err message contains one of msgs.
private static bool checkErrMessageContent(ErrorString e, params @string[] msgs)
{
msgs = msgs.Clone();
foreach (var(_, msg) in msgs)
{
if (contains(string(e), msg))
{
return(true);
}
}
return(false);
}
/// <summary></summary>
public override int GetHashCode()
{
var code = 13;
// Calculate hash on each properties one by one
code = (code * 7) + Id.GetHashCode();
if (CreationTime != null)
{
code = (code * 7) + CreationTime.GetHashCode();
}
if (this.ActionTypeUrl != null)
{
code = (code * 7) + ActionTypeUrl.GetHashCode();
}
if (this.ActionType != null)
{
code = (code * 7) + ActionType.GetHashCode();
}
code = (code * 7) + Discarded.GetHashCode();
if (this.StatusUrl != null)
{
code = (code * 7) + StatusUrl.GetHashCode();
}
if (this.Status != null)
{
code = (code * 7) + Status.GetHashCode();
}
if (this.ErrorString != null)
{
code = (code * 7) + ErrorString.GetHashCode();
}
if (this.User != null)
{
code = (code * 7) + User.GetHashCode();
}
if (this.ObjectUrl != null)
{
code = (code * 7) + ObjectUrl.GetHashCode();
}
if (this.AnnotationsUrl != null)
{
code = (code * 7) + AnnotationsUrl.GetHashCode();
}
if (this.Self != null)
{
code = (code * 7) + Self.GetHashCode();
}
return(code);
}
public static bool Is(this ErrorString e, error target)
{
if (target == oserror.ErrPermission)
{
return(checkErrMessageContent(e, "permission denied"));
}
else if (target == oserror.ErrExist)
{
return(checkErrMessageContent(e, "exists", "is a directory"));
}
else if (target == oserror.ErrNotExist)
{
return(checkErrMessageContent(e, "does not exist", "not found", "has been removed", "no parent"));
}
return(false);
}
//偵測Thread存在與否
private void Check_Run()
{
bool CheckStart = true;
while (CheckStart)
{
if (!MemInterface.ReadThread.IsAlive)
{
eventLog1.WriteEntry("ReadThread屬於停滯狀態");
}
if (!MemInterface.newthread.IsAlive)
{
eventLog1.WriteEntry("newthread屬於停滯狀態");
}
if (!MemInterface.ReadThread_Fanuc.IsAlive)
{
eventLog1.WriteEntry("ReadThread_Fanuc屬於停滯狀態");
}
if (!MemInterface.newthread_Fanuc.IsAlive)
{
eventLog1.WriteEntry("newthread_Fanuc屬於停滯狀態");
}
if (MemInterface.ReadThread.IsAlive & MemInterface.newthread.IsAlive & MemInterface.ReadThread.IsAlive & MemInterface.newthread_Fanuc.IsAlive)
{
eventLog1.WriteEntry("Thread皆正常運作");
}
if (!info.IsConnect())
{
eventLog1.WriteEntry("DELTA發生斷線，將進行重新連接的動作");
//Reconnect
int result = info.SetConnectInfo(DELTA_localIP1, DELTA_remoteIP1, Convert.ToInt32(DELTA_timeout1));
ErrorString ES = new ErrorString();
eventLog1.WriteEntry(ES.errorstring(result));
}
Thread.Sleep(300000); //每5分鐘進行執行緒的狀態確認
}
}
private static bool ReadTGAInfo(byte[] WorkPtr, out STargaHeader TargaHeader)
{
TargaHeader.PostHeaderSkip = WorkPtr[0];
TargaHeader.ColorMapType = WorkPtr[1];
TargaHeader.ImageType = WorkPtr[2];
TargaHeader.ColorMapStart = BitConverter.ToUInt16(WorkPtr, 3);
TargaHeader.ColorMapLength = BitConverter.ToUInt16(WorkPtr, 5);
TargaHeader.ColorMapBits = WorkPtr[7];
TargaHeader.XStart = BitConverter.ToUInt16(WorkPtr, 8);
TargaHeader.YStart = BitConverter.ToUInt16(WorkPtr, 10);
TargaHeader.Width = BitConverter.ToUInt16(WorkPtr, 12);
TargaHeader.Height = BitConverter.ToUInt16(WorkPtr, 14);
TargaHeader.BPP = WorkPtr[16];
TargaHeader.Descriptor = WorkPtr[17];
// check the header
if (TargaHeader.ColorMapType != 0 || // 0 = RGB, 1 = Palette
// 1 = Palette, 2 = RGB, 3 = mono, 9 = RLE Palette, 10 = RLE RGB, 11 RLE mono
(TargaHeader.ImageType != 2 && TargaHeader.ImageType != 10 && TargaHeader.ImageType != 9) ||
(TargaHeader.BPP != 24 && TargaHeader.BPP != 32))
{
#if DEBUG
throw new NotImplementedException("Unsupported TGA mode");
#endif
#if ASSERTS_ENABLED
if (((byte *)pTargaHeader)[0] == 'B' && ((byte *)pTargaHeader)[1] == 'M')
{
assert(!"This TGA's header looks like a BMP!"); // look at the first two bytes and see if they are 'BM'
// if so it's a BMP not a TGA
}
else
{
byte *pColorMapType = NULL;
switch (TargaHeader.ColorMapType)
{
case 0:
pColorMapType = "RGB Color Map";
break;
case 1:
pColorMapType = "Palette Color Map";
break;
default:
pColorMapType = "<Illegal Color Map>";
break;
}
byte *pImageType = NULL;
switch (TargaHeader.ImageType)
{
case 1:
pImageType = "Palette Image Type";
break;
case 2:
pImageType = "RGB Image Type";
break;
case 3:
pImageType = "mono Image Type";
break;
case 9:
pImageType = "RLE Palette Image Type";
break;
case 10:
pImageType = "RLE RGB Image Type";
break;
case 11:
pImageType = "RLE mono Image Type";
break;
default:
pImageType = "<Illegal Image Type>";
break;
}
int ColorDepth = TargaHeader.BPP;
CJString ErrorString;
ErrorString.Format("Image type %s %s (%u bpp) not supported!", pColorMapType, pImageType, ColorDepth);
ShowSystemMessage("TGA File IO Error", ErrorString.GetBytePtr(), "TGA Error");
}
#endif // ASSERTS_ENABLED
return(false);
}
return(true);
}
public void IsValid(string input, bool expectedResult)
{
bool isValid = ErrorString.IsValid(input);
Assert.Equal(expectedResult, isValid);
}
private async void PrintReport()
{
await PerformPrint(ErrorString?.Split('\n')?.ToList());
}
//*********************************************************************************************************************
static unsafe bool ReadTGAInfo(Byte *WorkPtr, out STargaHeader TargaHeader)
{
TargaHeader.PostHeaderSkip = WorkPtr[0];
TargaHeader.ColorMapType = WorkPtr[1];
TargaHeader.ImageType = WorkPtr[2];
TargaHeader.ColorMapStart = *((ushort *)(&WorkPtr[3]));
TargaHeader.ColorMapLength = *((ushort *)(&WorkPtr[5]));
TargaHeader.ColorMapBits = WorkPtr[7];
TargaHeader.XStart = *((ushort *)(&WorkPtr[8]));
TargaHeader.YStart = *((ushort *)(&WorkPtr[10]));
TargaHeader.Width = *((ushort *)(&WorkPtr[12]));
TargaHeader.Height = *((ushort *)(&WorkPtr[14]));
TargaHeader.BPP = WorkPtr[16];
TargaHeader.Descriptor = WorkPtr[17];
// check the header
if (TargaHeader.ColorMapType != 0 || // 0 = RGB, 1 = Palette
// 1 = Palette, 2 = RGB, 3 = mono, 9 = RLE Palette, 10 = RLE RGB, 11 RLE mono
(TargaHeader.ImageType != 2 && TargaHeader.ImageType != 10 && TargaHeader.ImageType != 9) ||
(TargaHeader.BPP != 24 && TargaHeader.BPP != 32))
{
#if ASSERTS_ENABLED
if (((Byte *)pTargaHeader)[0] == 'B' && ((Byte *)pTargaHeader)[1] == 'M')
{
assert(!"This TGA's header looks like a BMP!"); // look at the first two bytes and see if they are 'BM'
// if so it's a BMP not a TGA
}
else
{
Byte *pColorMapType = NULL;
switch (TargaHeader.ColorMapType)
{
case 0:
pColorMapType = "RGB Color Map";
break;
case 1:
pColorMapType = "Palette Color Map";
break;
default:
pColorMapType = "<Illegal Color Map>";
break;
}
Byte *pImageType = NULL;
switch (TargaHeader.ImageType)
{
case 1:
pImageType = "Palette Image Type";
break;
case 2:
pImageType = "RGB Image Type";
break;
case 3:
pImageType = "mono Image Type";
break;
case 9:
pImageType = "RLE Palette Image Type";
break;
case 10:
pImageType = "RLE RGB Image Type";
break;
case 11:
pImageType = "RLE mono Image Type";
break;
default:
pImageType = "<Illegal Image Type>";
break;
}
int ColorDepth = TargaHeader.BPP;
CJString ErrorString;
ErrorString.Format("Image type %s %s (%u bpp) not supported!", pColorMapType, pImageType, ColorDepth);
ShowSystemMessage("TGA File IO Error", ErrorString.GetBytePtr());
}
#endif // ASSERTS_ENABLED
return(false);
}
return(true);
}
public static @string Error(this ErrorString e)
{
return(string(e));
}
public static bool Timeout(this ErrorString e)
{
return(e == EBUSY || e == ETIMEDOUT);
}
public static bool Temporary(this ErrorString e)
{
return(e == EINTR || e == EMFILE || e.Timeout());
}
public void QueryTask(bool silent = false)
{
SchedTime = _oldTime != DateTime.MinValue ? _oldTime : new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, _random.Next(0, 23), _random.Next(0, 59), 0);
_responseString = string.Empty;
ErrorString = string.Empty;
var startInfo = new ProcessStartInfo()
{
FileName = "schtasks.exe",
Arguments = $"/query /xml /tn \"{TaskName}\"",
UseShellExecute = false,
CreateNoWindow = true,
RedirectStandardOutput = true,
RedirectStandardError = true
};
var proc = Process.Start(startInfo);
proc.OutputDataReceived += Proc_OutputDataReceived;
proc.BeginOutputReadLine();
proc.ErrorDataReceived += Proc_ErrorDataReceived;
proc.BeginErrorReadLine();
proc.WaitForExit();
if (proc.ExitCode == 0)
{
Exist = true;
ExistNoAccess = false;
var serializer = new XmlSerializer(typeof(taskType));
using (var reader = new StringReader(_responseString))
{
var task = (taskType)(serializer.Deserialize(reader));
Actions = new TaskActions[task.Actions.Exec.Length];
for (var i = 0; i < task.Actions.Exec.Length; ++i)
{
Actions[i].Path = task.Actions.Exec[i].Command;
Actions[i].Arguments = task.Actions.Exec[i].Arguments?.Replace("EPG:", "http:");
}
Wake = task.Settings.WakeToRun;
_oldTime = SchedTime = task.Triggers.Items[0].StartBoundary.Date +
task.Triggers.Items[0].StartBoundary.TimeOfDay;
}
_responseString = string.Empty;
startInfo.Arguments = $"/query /fo csv /v /tn \"{TaskName}\"";
proc = Process.Start(startInfo);
proc.OutputDataReceived += Proc_OutputDataReceived;
proc.BeginOutputReadLine();
proc.WaitForExit();
if (!string.IsNullOrEmpty(_responseString))
{
StatusString = string.Empty;
var lines = _responseString.Split('\n');
var columns = lines[0].Replace("\",\"", "|").TrimStart('\"').TrimEnd('\"').Split('|');
var values = lines[1].Replace("\",\"", "|").TrimStart('\"').TrimEnd('\"').Split('|');
for (var i = 0; i < columns.Length; ++i)
{
switch (columns[i])
{
case "Status":
StatusString += $"{values[i]}.";
break;
case "Last Run Time":
if (DateTime.TryParse(values[i], out var dt) && (dt.Year > 2015))
{
StatusString += $" Last Run {values[i]};";
}
else
{
StatusString += "The task has not yet run.";
}
break;
case "Last Result":
StatusString += $" Exit: 0x{int.Parse(values[i]):X8}";
break;
}
}
}
}
else if (ErrorString.ToLower().Contains("access")) // permission problem
{
Exist = false;
ExistNoAccess = true;
StatusString = ErrorString;
}
else
{
Exist = ExistNoAccess = false;
StatusString = "No task is scheduled to run.";
}
if (!silent)
{
Logger.WriteVerbose($"Successfully queried the Task Scheduler for status. {StatusString}");
}
}
