public void Initialize(TRunner tunitRunner, List <string> testcaseIDList, List <ItemData> listItem)
{
_toastMessage = new ToastMessage();
RunType.Value = RunType.MANUAL;
_tunitRunner = tunitRunner;
_tunitRunner.SingleTestDone += OnSingleTestDone;
_tcInfoList = new List <TestcaseInfo>();
_tcIDList = testcaseIDList;
_tsettings = TSettings.GetInstance();
_tsettings.IsManual = true;
_listItem = listItem;
MakeTCInfoList();
_summaryLabel1 = new Label()
{
Text = "",
HeightRequest = 25,
HorizontalOptions = LayoutOptions.Center,
VerticalOptions = LayoutOptions.Center,
TextColor = Color.White,
FontSize = 5,
};
_summaryLabel2 = new Label()
{
Text = "",
HeightRequest = 25,
HorizontalOptions = LayoutOptions.Center,
VerticalOptions = LayoutOptions.Center,
TextColor = Color.White,
FontSize = 5,
};
SetResultNumber(0, 0, 0);
MakeTestPage();
}
public TRunner(Assembly testAssembly)
{
_testAssembly = testAssembly;
#if TIZEN
TSettings.GetInstance().ConnectTestkitStub();
#endif
}
public TSettings LoadOrCreate <TSettings>() where TSettings : class, new()
{
var settingsFilePath = GetSettingsFilePath(typeof(TSettings));
if (!File.Exists(settingsFilePath))
{
var settings = new TSettings();
this.Save(settings);
return(settings);
}
var settingsFileInfo = new FileInfo(settingsFilePath);
if (settingsFileInfo.Length > 1 * 1024 * 1024)
{
throw new InvalidOperationException("Refusing to load settings files larger than 1 MB in size.");
}
try
{
var fileBytes = File.ReadAllBytes(settingsFilePath);
return(JsonSerializer.Deserialize <TSettings>(fileBytes) ?? new TSettings());
}
catch
{
var settings = new TSettings();
this.Save(settings);
return(settings);
}
}
/// <summary>
/// Execute the test suite automatically on the Tizen devidce
/// </summary>
public void LoadTestsuite(string dllPath, string pkgName)
{
TSettings.CurTCIndex = 0;
if (pkgName == "")
{
TLogger.Write("The package name is invalid!");
return;
}
TLogger.Write("Executing the application: " + pkgName + "...");
string exeFilePathName = string.Format(dllPath + "Tizen.{0}.Tests.exe", pkgName);
AssemblyName asmName = new AssemblyName(GetAssemblyName(exeFilePathName));
_testAssembly = Assembly.Load(asmName);
string pkgShareDir = string.Format("/home/owner/share/{0}", pkgName);
System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(pkgShareDir);
if (di.Exists == false)
{
di.Create();
}
string outputFilePathName = string.Format("{0}/{1}.xml", pkgShareDir, TESTCASE_XML_NAME);
TSettings.GetInstance().SetOutputFilePathName(outputFilePathName);
string[] s = new string[1] { exeFilePathName };
//new TextRunner(_testAssembly).Execute(s);
LoadTestsuite(s, outputFilePathName);
}
public void ReportResults(ITestResult result)
{
Summary = new ResultSummary(result);
if (Summary.ExplicitCount + Summary.SkipCount + Summary.IgnoreCount > 0)
{
_textUI.DisplayNotRunReport(result);
}
if (result.ResultState.Status == TestStatus.Failed)
{
_textUI.DisplayErrorsAndFailuresReport(result);
}
#if FULL
if (_options.Full)
{
_textUI.PrintFullReport(_result);
}
#endif
if (TSettings.GetInstance().IsManual == false)
{
_textUI.DisplayRunSettings();
_textUI.DisplaySummaryReport(Summary);
}
}
/// <summary>
/// Load setting from default path.
/// </summary>
/// <typeparam name="TSettings">Type of settings class</typeparam>
/// <returns>Parsed settings. If file is not exist - return default</returns>
public static TSettings Load <TSettings>()
where TSettings : SettingsJson, new()
{
var settings = new TSettings();
return(Load <TSettings>(settings.FilePath));
}
public bool SafeRegister <TSettings, TPanel>(params string[] groups)
where TSettings : GenericSettings, new()
where TPanel : Control, Editable <TSettings>, new()
{
string name = new TSettings().SettingsID;
if (byName(name) != null)
{
return(false);
}
if (bySettingsType(typeof(TSettings)) != null)
{
return(false);
}
ProfileType p = new SpecificProfileType <TSettings, TPanel>(name);
profileTypes.Add(p);
foreach (string g in groups)
{
groupByName(g).Register(p, name, typeof(TSettings));
}
return(true);
}
public static TSettings CreateDefaultInstance <TSettings>() where TSettings : class, new()
{
var settings = new TSettings();
var settingsEntryMembers =
typeof(TSettings).GetMembersWithCustomAttributeNoInherit <SettingsEntryAttribute>();
foreach (var settingsEntryMember in settingsEntryMembers)
{
var attribute = settingsEntryMember.GetCustomAttributeNoInherit <SettingsEntryAttribute>();
var settingsField = settingsEntryMember as FieldInfo;
if (settingsField != null)
{
var fieldType = settingsField.FieldType;
var defaultValue = GetDefaultValue(attribute, fieldType);
settingsField.SetValue(settings, defaultValue);
continue;
}
var settingsProperty = settingsEntryMember as PropertyInfo;
if (settingsProperty != null)
{
var propertyType = settingsProperty.PropertyType;
var defaultValue = GetDefaultValue(attribute, propertyType);
settingsProperty.SetValue(settings, defaultValue, new object[0]);
continue;
}
Asserts.Fail("unhandled settings-member type: {0}", settingsEntryMember.GetType());
}
return(settings);
}
private TSettings GetNewSettingsObject <TSettings>() where TSettings : SiteSettingsBase, new()
{
TSettings settings = new TSettings();
_legacySettingsProvider.ApplyLegacySettings(settings, _site.Id);
return(settings);
}
/// <summary>
/// Execute the tests in the assembly, passing in
/// a list of arguments.
/// </summary>
/// <param name="args">arguments for NUnitLite to use</param>
public void Execute()
{
#if TIZEN
#region tronghieu.d - Create new thread to run test and mainthread waiting for invoke test method.
TAsyncThreadMgr asyncThreadMgr = TAsyncThreadMgr.GetInstance();
ManualResetEvent methodExecutionResetEvent = asyncThreadMgr.GetMethodExecutionResetEvent();
methodExecutionResetEvent.Reset();
Task t = Task.Run(() =>
{
_textRunner.Execute(args);
asyncThreadMgr.SetData(null, null, null, null, false);
methodExecutionResetEvent.Set();
});
t.GetAwaiter().OnCompleted(() =>
{
OnSingleTestDone(TSettings.GetInstance().GetSingleTestDoneEventArgs());
});
methodExecutionResetEvent.WaitOne();
asyncThreadMgr.RunTestMethod();
#endregion
#else
new TextRunner(_testAssembly).Execute(args);
#endif
}
internal P_State(TSettings settings, bool setOnceMark, bool getOnceMark, ExceptionDispatchInfo validationError)
{
Settings = settings;
SetOnceMark = setOnceMark;
GetOnceMark = getOnceMark;
ValidationError = validationError;
}
public Experiment()
{
Settings = new TSettings();
timer.Interval = 250;
timer.Tick += OnDataReceived;
ExperimentCaption = "Заглушка";
}
public TRunner(Assembly testAssembly)
{
_testAssembly = testAssembly;
Tizen.Log.Fatal("NUITEST", $"");
Tizen.Log.Fatal("NUITEST", $"TRunner() _testAssembly={_testAssembly}");
#if TIZEN
TSettings.GetInstance().ConnectTestkitStub();
#endif
}
/// <summary>
/// Construct a CompositeWorkItem for executing a test suite
/// using a filter to select child tests.
/// </summary>
/// <param name="suite">The TestSuite to be executed</param>
/// <param name="childFilter">A filter used to select child tests</param>
public CompositeWorkItem(TestSuite suite, ITestFilter childFilter)
: base(suite)
{
_suite = suite;
_suiteResult = Result as TestSuiteResult;
_childFilter = childFilter;
_countOrder = 0;
tsettings = TSettings.GetInstance();
}
/// <summary>
/// Execute the test suite automatically on the Tizen devidce
/// </summary>
public void LoadTestsuite()
{
Tizen.Log.Fatal("NUITEST", $"");
Tizen.Log.Fatal("NUITEST", $"LoadTestsuite()");
TSettings.CurTCIndex = 0;
string cache_path = Tizen.Applications.Application.Current.DirectoryInfo.Resource;
string dllPath = cache_path.Replace("res", "bin");//Cache->res
string pkgName = GetPackageName(dllPath);
if (pkgName == "")
{
Tizen.Log.Fatal("NUITEST", $"The package name is invalid!");
TLogger.WriteError("The package name is invalid!");
return;
}
//TLogger.Write("Executing the application: " + pkgName + "...");
Tizen.Log.Fatal("NUITEST", $"Executing the application: {pkgName}");
string exeFilePathName = "";
if (dllPath.Contains("netcoreapp"))
{
exeFilePathName = string.Format(dllPath + "Tizen.{0}Tests.dll", pkgName);
}
else
{
exeFilePathName = string.Format(dllPath + "Debug/netcoreapp3.1/Tizen.{0}dll", pkgName);
}
//TLogger.Write("exeFilePathName : " + exeFilePathName);
Tizen.Log.Fatal("NUITEST", $"exeFilePathName : {exeFilePathName}");
AssemblyName asmName = new AssemblyName(GetAssemblyName(exeFilePathName));
_testAssembly = Assembly.LoadFrom(exeFilePathName);
string pkgShareDir = $"{dllPath}{pkgName}";
System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(pkgShareDir);
if (di.Exists == false)
{
di.Create();
}
string outputFilePathName = string.Format("{0}/{1}.xml", pkgShareDir, TESTCASE_XML_NAME);
TSettings.GetInstance().SetOutputFilePathName(outputFilePathName);
string[] s = new string[1] {
exeFilePathName
};
Tizen.Log.Fatal("NUITEST", $"outputFilePathName : {outputFilePathName}");
//new TextRunner(_testAssembly).Execute(s);
LoadTestsuite(s, outputFilePathName);
}
public TSettings CreateExportSettings <TSettings>()
where TSettings : UTinyAssetExportSettings, new()
{
var settings = new TSettings()
{
VersionStorage = VersionStorage
};
s_ExportSettings.SetValue(this, settings);
return(settings);
}
//Constructor FromString( s, Settings)
public TGameRR(string s, TSettings Settings)
{
string[] a;
string[] b;
int i;
int j;
this.Settings = Settings;
// Create Match to point on later
CurrentMatch = new TMatch();
CurrentA = 0;
CurrentB = 0;
a = UHelpers.UHelpers.Explode(s, Units.Class.SEP_GAME);
// Players + nPlayers
b = UHelpers.UHelpers.Explode(a[1], Units.Class.SEP_LIST);
nPlayers = b.Length;
Players = new TPlayer[nPlayers];
for (i = 0; i < nPlayers; i++)
{
Players[i] = new TPlayer(b[i]);
}
// PointsGrid
b = UHelpers.UHelpers.Explode(a[2], Units.Class.SEP_LIST);
PointsGrid = new int[nPlayers, nPlayers];
for (i = 0; i < nPlayers; i++)
{
for (j = 0; j < nPlayers; j++)
{
PointsGrid[i, j] = Convert.ToInt32(b[i * nPlayers + j]);
}
}
// TimeGrid
b = UHelpers.UHelpers.Explode(a[3], Units.Class.SEP_LIST);
TimeGrid = new int[nPlayers, nPlayers];
for (i = 0; i < nPlayers; i++)
{
for (j = 0; j < nPlayers; j++)
{
TimeGrid[i, j] = Convert.ToInt32(b[i * nPlayers + j]);
}
}
// CountList
b = UHelpers.UHelpers.Explode(a[4], Units.Class.SEP_LIST);
CountList = new int[nPlayers];
for (i = 0; i < nPlayers; i++)
{
CountList[i] = Convert.ToInt32(b[i]);
}
// TimeStarted
TimeStarted = Convert.ToDateTime(a[5]);
}
public ServiceHostBase(
TSettings settings,
Func <TSettings, TService> serviceFactory,
Type serviceType,
params Uri[] baseAddresses
)
: base(serviceType, baseAddresses)
{
foreach (var contractDescription in this.ImplementedContracts.Values)
{
var provider = new ServiceInstanceProviderBase(settings, serviceFactory);
contractDescription.Behaviors.Add(provider);
}
}
private GetSettingsObject <TSettings> GetSettingObject <TSettings>() where TSettings : SiteSettingsBase, new()
{
string fileLocation = GetFileLocation(typeof(TSettings));
TSettings result = null;
if (File.Exists(fileLocation))
{
string readAllText = File.ReadAllText(fileLocation);
result = JsonConvert.DeserializeObject <TSettings>(readAllText);
}
return(result != null
? new GetSettingsObject <TSettings>(result)
: new GetSettingsObject <TSettings>(GetNewSettingsObject <TSettings>(), true));
}
/// <summary>
/// 转换为子对象（拷贝对象实例）。
/// </summary>
/// <typeparam name="TSettings">配置类型。</typeparam>
/// <returns>返回转换后的对象。</returns>
public virtual TSettings As <TSettings>() where TSettings : SmsSettings, new()
{
var settings = new TSettings();
foreach (var extendKey in ExtendKeys)
{
settings[extendKey] = this[extendKey];
}
settings.Client = Client;
settings.Id = Id;
settings.AppId = AppId;
settings.AppSecret = AppSecret;
return(settings);
}
public MainPage()
{
_tunitrunner = new TRunner();
_tunitrunner.LoadTestsuite();
_listNotPass = new List <string>();
_tcIDList = new List <string>();
_listItem = new List <ItemData>();
_listNotPass = TSettings.GetInstance().GetNotPassListManual();
int count = 0;
if (_listNotPass.Count == 0)
{
foreach (KeyValuePair <string, ITest> pair in _tunitrunner.GetTestList())
{
count++;
_listItem.Add(new ItemData {
No = count, TCName = pair.Key, Result = StrResult.NOTRUN
});
_tcIDList.Add(pair.Key);
}
}
else
{
foreach (var tc in _listNotPass)
{
count++;
_listItem.Add(new ItemData {
No = count, TCName = tc, Result = StrResult.NOTRUN
});
_tcIDList.Add(tc);
}
}
ResultNumber.Total = ResultNumber.NotRun = _tcIDList.Count;
if (_listItem.Count != 0)
{
_testPage = TestPage.GetInstance();
_testPage.Initialize(_tunitrunner, _tcIDList, _listItem);
_testPage.TestcaseDone += OnTestcaseDone;
}
MakeWindowPage();
_navigationPage = new NavigationPage(_mainContentPage);
NavigationPage.SetHasNavigationBar(_mainContentPage, false);
MainPage = _navigationPage;
}
public TSettings LoadData <TSettings>()
where TSettings : ISettings, new()
{
var settings = new TSettings();
var fullpath = MakeFilename(settings);
lock (_latch)
{
if (File.Exists(fullpath))
{
var json = File.ReadAllText(fullpath);
return(JsonConvert.DeserializeObject <TSettings>(json));
}
}
return(settings);
}
/// <summary>
/// Method that performs actually performs the work.
/// </summary>
protected override void PerformWork()
{
try
{
Result = _command.Execute(Context);
// [DuongNT]: Write out the method's results
if (!TSettings.GetInstance().IsSlaveMode&& !TSettings.GetInstance().IsManual)
{
TLogger.Write("##### Result of [" + Result.FullName + "] TC : " + Result.ResultState.ToString());
}
}
finally
{
WorkItemComplete();
}
}
public TSettings GetSettings <TSettings>() where TSettings : ISettings, new()
{
TSettings settings = Activator.CreateInstance <TSettings>();
// get properties we can write to
var properties = from prop in typeof(TSettings).GetProperties()
where prop.CanWrite && prop.CanRead
let setting = this.GetSettingByKey <string>(typeof(TSettings).Name + "." + prop.Name)
where setting != null
where ConvertHelper.GetCustomTypeConverter(prop.PropertyType).CanConvertFrom(typeof(string))
let value = ConvertHelper.GetCustomTypeConverter(prop.PropertyType).ConvertFromInvariantString(setting)
select new { prop, value };
// assign properties
properties.ToList().ForEach(p => p.prop.SetValue(settings, p.value, null));
return(settings);
}
public TSettings GetSiteSettings <TSettings>() where TSettings : SiteSettingsBase, new()
{
lock (ReadLockObject)
{
if (!GetSiteCache().ContainsKey(typeof(TSettings)))
{
GetSettingsObject <TSettings> settingObject = GetSettingObject <TSettings>();
TSettings settings = settingObject.Settings;
if (settingObject.IsNew)
{
SaveSettings(settings);
}
else
{
GetSiteCache()[settings.GetType()] = settings;
}
}
return(GetSiteCache()[typeof(TSettings)] as TSettings);
}
}
static IComponentRegistration BuildRegistration <TSettings>() where TSettings : ISettings, new()
{
return(RegistrationBuilder
.ForDelegate((c, p) =>
{
TSettings settings = default;
int currentStoreId = c.ResolveOptional <IStoreContext>()?.CurrentStore?.Id ?? 0;
var settingFactory = c.ResolveOptional <ISettingFactory>();
if (settingFactory != null)
{
settings = settingFactory.LoadSettings <TSettings>(currentStoreId);
}
return settings ?? new TSettings();
})
//.InstancePerLifetimeScope()
.ExternallyOwned()
.CreateRegistration());
}
//Constructor Create( Candidates, Settings)
public TGameRR(TPlayer[] Candidates, TSettings Settings)
{
int i;
int j;
this.Settings = Settings;
nPlayers = Candidates.Length;
TimeStarted = DateTime.MinValue; //done in GetNextMatch
// Copy Players to own List
Players = new TPlayer[nPlayers];
for (i = 0; i < nPlayers; i++)
{
Players[i] = Candidates[i];
Players[i].ID = i;
}
// Init Matrix and Counter Table
PointsGrid = new int[nPlayers, nPlayers];
TimeGrid = new int[nPlayers, nPlayers];
CountList = new int[nPlayers];
for (i = 0; i < nPlayers; i++)
{
for (j = 0; j < nPlayers; j++)
{
if (i == j)
{
PointsGrid[i, j] = -1;
TimeGrid[i, j] = -1;
}
else
{
PointsGrid[i, j] = 0;
TimeGrid[i, j] = 0;
}
}
CountList[i] = 99;
}
// Create Match to point on later
CurrentMatch = new TMatch();
CurrentA = 0;
CurrentB = 0;
}
public async Task <TSettings> LoadAutoSaveAsync <TSettings>() where TSettings : class, ISettings, INotifyPropertyChanged, new()
{
return(await Task <TSettings> .Factory.StartNew(() =>
{
var exists = File.Exists(Path);
if (exists)
{
try
{
using (var sr = File.Open(Path, FileMode.Open))
{
var settings = (TSettings) new BinaryFormatter().Deserialize(sr);
settings.PropertyChanged += async(s, e) =>
{
await SaveAsync(settings);
};
return settings;
}
}
catch
{
var settings = new TSettings();
settings.PropertyChanged += async(s, e) =>
{
await SaveAsync(settings);
};
return settings;
}
}
else
{
var settings = new TSettings();
settings.PropertyChanged += async(s, e) =>
{
await SaveAsync(settings);
};
return settings;
}
}));
}
/// <summary>
/// Load a Settings.
/// </summary>
/// <typeparam name="TSettings">The Generic of the Settings.</typeparam>
/// <returns>Instanced <typeparamref name="TSettings"/></returns>
/// <remarks>If the process is wrong, returns a default instanced <typeparamref name="TSettings"/></remarks>
public TSettings LoadAutoSave <TSettings>() where TSettings : ISettings, INotifyPropertyChanged, new()
{
var exists = File.Exists(Path);
if (exists)
{
try
{
using (var sr = File.Open(Path, FileMode.Open))
{
var settings = (TSettings) new BinaryFormatter().Deserialize(sr);
settings.PropertyChanged += (s, e) =>
{
Save(settings);
};
return(settings);
}
}
catch
{
var settings = new TSettings();
settings.PropertyChanged += (s, e) =>
{
Save(settings);
};
return(settings);
}
}
else
{
var settings = new TSettings();
settings.PropertyChanged += (s, e) =>
{
Save(settings);
};
return(settings);
}
}
/// <summary>
/// Write the result of a test run according to a spec.
/// </summary>
/// <param name="result">The test result</param>
/// <param name="spec">An output specification</param>
/// <param name="runSettings">Settings</param>
/// <param name="filter">Filter</param>
public void WriteResultFile(ITestResult result, OutputSpecification spec, IDictionary <string, object> runSettings, TestFilter filter)
{
//string outputPath = Path.Combine(_workDirectory, spec.OutputPath);
// [DuongNT][BEGIN]: Get configured file path output
// Write results log
ResultSummary summary = new ResultSummary(result);
int totalTCT = summary.TestCount;
int passedTCT = summary.PassCount;
int failedTCT = summary.FailedCount;
int blockTCT = totalTCT - passedTCT - failedTCT;
TLogger.Write("");
TLogger.Write("#####Summary#####");
TLogger.Write("##### Total #####");
TLogger.Write("##### " + totalTCT + " #####");
TLogger.Write("##### PASS #####");
TLogger.Write("##### " + passedTCT + " #####");
TLogger.Write("##### FAIL #####");
TLogger.Write("##### " + failedTCT + " #####");
TLogger.Write("##### BLOCK #####");
TLogger.Write("##### " + blockTCT + " #####");
TLogger.Write("##### Details #####");
TLogger.Write("");
string outputPath = TSettings.GetInstance().GetOutputFilePathName();
if (outputPath == "")
{
outputPath = Path.Combine(_workDirectory, spec.OutputPath);
}
TLogger.Write("Completed test-suite's execution!");
TLogger.Write("Writing results to: " + outputPath + "...");
// [DuongNT][END]: Get configured file path output
OutputWriter outputWriter = null;
switch (spec.Format)
{
case "nunit3":
outputWriter = new NUnit3XmlOutputWriter();
break;
case "nunit2":
outputWriter = new NUnit2XmlOutputWriter();
break;
//case "user":
// Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
// string dir = Path.GetDirectoryName(uri.LocalPath);
// outputWriter = new XmlTransformOutputWriter(Path.Combine(dir, spec.Transform));
// break;
default:
throw new ArgumentException(
string.Format("Invalid XML output format '{0}'", spec.Format),
"spec");
}
outputWriter.WriteResultFile(result, outputPath, runSettings, filter);
TLogger.Write("Results saved to: " + outputPath);
}
public ServiceInstanceProviderBase(TSettings settings, Func <TSettings, TService> serviceFactory)
{
this.settings = settings;
this.serviceFactory = serviceFactory;
}
