public static void ConstructorATest(DBDataSettingType type, DBKind dbKind, TypeId?typeId,
bool isError)
{
DBType instance = null;
var errorOccured = false;
try
{
instance = new DBType(type, dbKind, typeId);
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーフラグが一致すること
Assert.AreEqual(errorOccured, isError);
if (errorOccured)
{
return;
}
// 各プロパティがセットした値と一致すること
Assert.AreEqual(instance.DataSettingType, type);
if (type == DBDataSettingType.DesignatedType)
{
Assert.NotNull(dbKind);
Assert.AreEqual(instance.DBKind, dbKind);
Assert.NotNull(typeId);
Assert.AreEqual(instance.TypeId, typeId.Value);
}
}
/// <summary>
/// タイプ名を指定してタイプIDを取得する。
/// </summary>
/// <param name="dbKind">[NotNull] DB種別</param>
/// <param name="name">[NotNull] タイプ名</param>
/// <returns>タイプID。見つからない場合null。</returns>
/// <exception cref="ArgumentNullException">dbKind または name が null の場合</exception>
public (int?, string) GetDatabaseTypeId(DBKind dbKind, string name)
{
if (dbKind is null)
{
throw new ArgumentNullException(
ErrorMessage.NotNull(nameof(dbKind)));
}
if (name is null)
{
throw new ArgumentNullException(
ErrorMessage.NotNull(nameof(name)));
}
var refer = GetDatabaseRefer(dbKind);
var searchTypeId = -1;
for (var i = 0; i < refer.TypeDescList.Count; i++)
{
if (refer.TypeDescList[i].TypeName.Equals(name))
{
searchTypeId = i;
break;
}
}
if (searchTypeId == -1)
{
return(null, TargetIdNotFound);
}
return(searchTypeId, searchTypeId.ToString());
}
/// <summary>
/// データIDの設定方法
/// </summary>
/// <param name="status">読み込み経過状態</param>
/// <param name="setting">結果格納インスタンス</param>
private void ReadDataSettingType(FileReadStatus status, DBDataSetting setting)
{
var typeCode = status.ReadInt();
status.IncreaseIntOffset();
var settingType = DBDataSettingType.FromValue(typeCode);
Logger.Debug(FileIOMessage.SuccessRead(typeof(DBDataSettingReader),
"データID設定方法", settingType));
// 「指定DBの指定タイプ」の場合、DB種別とタイプIDを取り出す
DBKind dbKind = null;
TypeId typeId = 0;
if (settingType == DBDataSettingType.DesignatedType)
{
dbKind = DbKindFromSettingTypeCode(typeCode);
Logger.Debug(FileIOMessage.SuccessRead(typeof(DBDataSettingReader),
"DB種別", dbKind));
typeId = TypeIdFromSettingTypeCode(typeCode);
Logger.Debug(FileIOMessage.SuccessRead(typeof(DBDataSettingReader),
"タイプID", typeId));
}
setting.SetDataSettingType(settingType, dbKind, typeId);
}
public static void SetDatabaseReferTest(DBKind dbKind, int dbTypeId)
{
var typeId = (TypeId)dbTypeId;
var instance = new CommonEventSpecialNumberArgDesc.InnerDescNormal();
var changedPropertyList = new List <string>();
instance.PropertyChanged += (sender, args) => { changedPropertyList.Add(args.PropertyName); };
var errorOccured = false;
try
{
instance.SetDatabaseRefer(dbKind, typeId);
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーが発生すること
Assert.IsTrue(errorOccured);
// プロパティ変更通知が発火していないこと
Assert.AreEqual(changedPropertyList.Count, 0);
}
public static void WriteSyncTest(DatabaseMergedData outputDat, DBKind dbKind)
{
DatabaseMergedDataWriter writer = null;
if (dbKind == DBKind.User)
{
var datFilePath =
(ChangeableDatabaseDatFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\DatabaseMergedDataWriterTest\CDatabase.dat";
var projectFilePath =
(ChangeableDatabaseProjectFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\DatabaseMergedDataWriterTest\CDatabase.project";
writer = new DatabaseMergedDataWriter(outputDat, datFilePath, projectFilePath);
}
else if (dbKind == DBKind.System)
{
var datFilePath =
(ChangeableDatabaseDatFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\DatabaseMergedDataWriterTest\SysDatabase.dat";
var projectFilePath =
(ChangeableDatabaseProjectFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\DatabaseMergedDataWriterTest\SysDatabase.project";
writer = new DatabaseMergedDataWriter(outputDat, datFilePath, projectFilePath);
}
else if (dbKind == DBKind.Changeable)
{
var datFilePath =
(ChangeableDatabaseDatFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\DatabaseMergedDataWriterTest\CDatabase.dat";
var projectFilePath =
(ChangeableDatabaseProjectFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\DatabaseMergedDataWriterTest\CDatabase.project";
writer = new DatabaseMergedDataWriter(outputDat, datFilePath, projectFilePath);
}
Assert.NotNull(writer);
var isSuccess = false;
var errorMessage = "";
try
{
writer.WriteSync();
isSuccess = true;
}
catch (Exception e)
{
errorMessage = e.Message;
}
// 出力成功すること
if (!isSuccess)
{
throw new InvalidOperationException(
$"Error message: {errorMessage}");
}
Assert.True(true);
}
public IDbConnection GetConnection(DBKind dbKind, string connectionString, string schema)
{
try {
return(GetConnection(dbKind, new ConnectionString(connectionString), schema));
} catch (InvalidDatabaseAccessException e) {
throw new InvalidDBTransactionManagerAccess(e.Message);
}
}
public IDbConnection GetConnection(DBKind dbKind, ConnectionString connectionString, string schema)
{
try {
return(AdaptersUtils.GetDatabaseServices(dbKind, connectionString, schema).TransactionService.CreateConnection());
} catch (InvalidDatabaseAccessException e) {
throw new InvalidDBTransactionManagerAccess(e.Message);
}
}
public static IDataReader ExecuteStoredProcedure(IDbCommand cmd, DBKind dbKind, string readerVarName)
{
try {
return(ExecuteStoredProcedure(cmd, dbKind, readerVarName, false));
} catch (InvalidDatabaseAccessException e) {
throw new InvalidDBTransactionManagerAccess(e.Message);
}
}
public static string CreateONSConfig(DBKind dbKind, string dbServerScan, string onsPort)
{
if (onsPort == null)
{
return(null);
}
return("nodes=" + dbServerScan + ":" + onsPort);
}
internal static IPlatformDatabaseServices GetDatabaseServices(DBKind dbKind, ConnectionString connectionString, string schema)
{
var pluginProvider = new DatabasePluginProvider <IPlatformDatabaseProvider>(GetDatabasePluginsPath());
var provider = pluginProvider.GetImplementation(DatabaseProviderKey.Deserialize(dbKind.ToString()));
var databaseConfiguration = CreateDatabaseConfiguration(provider, connectionString.GetConnectionString(),
connectionString.GetOnsConfig(), String.Empty, schema);
return(provider.GetPlatformDatabaseServices(databaseConfiguration));
}
// _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
// Public Property
// _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="filePath">読み込みファイルパス</param>
/// <param name="dbKind">読み込みDB種別</param>
/// <exception cref="ArgumentNullException">filePath, dbKindがnullの場合</exception>
public DatabaseProjectFileReader(DatabaseProjectFilePath filePath, DBKind dbKind) : base(filePath)
{
if (dbKind is null)
{
throw new ArgumentNullException(
ErrorMessage.NotNull(nameof(dbKind)));
}
DBKind = dbKind;
ReadStatus = new FileReadStatus(FilePath);
}
public static IDataReader ExecuteStoredProcedure(IDbCommand command, DBKind dbKind, string readerVarName, bool skipLog)
{
try {
IDbCommand cmd = ADOAdaptersUtils.GetADOCommand(command);
TransformParameters(cmd);
IDataReader reader = GetExecutionForKind(dbKind).ExecuteStoredProcedureWithResultSet(cmd, readerVarName);
DatabaseAccess.GetProviderForTransaction(cmd.Transaction).TransactionManager.AssociateReader(cmd.Transaction, reader);
return(reader);
} catch (InvalidDatabaseAccessException e) {
throw new InvalidDBTransactionManagerAccess(e.Message);
}
}
public static void GetAllSpecialCaseNumberTest(DBKind dbKind, int dbTypeId, bool isUseAddition,
int answerCaseNumberLength, int answerDbTypeCode, int answerUseAdditionValue)
{
var instance = new CommonEventSpecialNumberArgDesc.InnerDescDatabase();
instance.SetDatabaseRefer(dbKind, dbTypeId);
instance.SetDatabaseUseAdditionalItemsFlag(isUseAddition);
var changedDescPropertyList = new List <string>();
instance.PropertyChanged += (sender, args) => { changedDescPropertyList.Add(args.PropertyName); };
var changedSpecialArgCaseListPropertyList = new List <string>();
instance.SpecialArgCaseList.PropertyChanged += (sender, args) =>
{
changedSpecialArgCaseListPropertyList.Add(args.PropertyName);
};
var changedSpecialArgCaseListCollectionArgList = new List <NotifyCollectionChangedEventArgs>();
instance.SpecialArgCaseList.CollectionChanged += (sender, args) =>
{
changedSpecialArgCaseListCollectionArgList.Add(args);
};
var errorOccured = false;
try
{
instance.GetAllSpecialCaseNumber();
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーが発生しないこと
Assert.IsFalse(errorOccured);
// 意図した値が取得できること
var caseNumberList = instance.GetAllSpecialCaseNumber();
Assert.AreEqual(caseNumberList.Count, answerCaseNumberLength);
Assert.AreEqual(caseNumberList[0], answerDbTypeCode);
Assert.AreEqual(caseNumberList[1], dbTypeId);
Assert.AreEqual(caseNumberList[2], answerUseAdditionValue);
// プロパティ変更通知が発火していないこと
Assert.AreEqual(changedDescPropertyList.Count, 0);
Assert.AreEqual(changedSpecialArgCaseListPropertyList.Count, 0);
Assert.AreEqual(changedSpecialArgCaseListCollectionArgList.Count, 0);
}
internal static IPlatformDatabaseServices GetDatabaseServicesForKind(DBKind kind)
{
switch (kind)
{
case DBKind.Oracle:
return(dummyDatabaseServicesForOracle);
case DBKind.SqlServer:
return(dummyDatabaseServicesForSQLServer);
}
throw new InvalidOperationException();
}
public static void SetDataSettingTypeTest(DBDataSettingType settingType, DBKind dbKind,
TypeId?typeId, bool isError)
{
var instance = CreateTypeDesc(1, 0);
var changedPropertyList = new List <string>();
instance.PropertyChanged += (sender, args) => { changedPropertyList.Add(args.PropertyName); };
var errorOccured = false;
try
{
instance.SetDataSettingType(settingType, dbKind, typeId);
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーフラグが一致すること
Assert.AreEqual(errorOccured, isError);
if (!errorOccured)
{
// 各プロパティが意図した値と一致すること
Assert.AreEqual(instance.DataSettingType, settingType);
if (settingType != DBDataSettingType.DesignatedType)
{
return;
}
Assert.NotNull(typeId);
Assert.AreEqual(instance.DBKind, dbKind);
Assert.AreEqual(instance.TypeId, typeId.Value);
}
// 意図したとおりプロパティ変更通知が発火していること
if (errorOccured)
{
Assert.AreEqual(changedPropertyList.Count, 0);
}
else
{
Assert.AreEqual(changedPropertyList.Count, 3);
Assert.IsTrue(changedPropertyList[0].Equals(nameof(DatabaseTypeDesc.DataSettingType)));
Assert.IsTrue(changedPropertyList[1].Equals(nameof(DatabaseTypeDesc.DBKind)));
Assert.IsTrue(changedPropertyList[2].Equals(nameof(DatabaseTypeDesc.TypeId)));
}
}
/// <summary>
/// タイプID、データ名を指定してデータIDを取得する。
/// </summary>
/// <param name="dbKind">[NotNull] DB種別</param>
/// <param name="typeId">タイプID</param>
/// <param name="dataName">[NotNull] データ名</param>
/// <returns>
/// データID。
/// データが見つからない場合、null。
/// </returns>
/// <exception cref="ArgumentNullException">dbKind または dataName が null の場合</exception>
public (int?, string) GetDatabaseDataId(DBKind dbKind, int?typeId,
string dataName)
{
if (dbKind is null)
{
throw new ArgumentNullException(
ErrorMessage.NotNull(nameof(dbKind)));
}
if (dataName is null)
{
throw new ArgumentNullException(
ErrorMessage.NotNull(nameof(dataName)));
}
if (typeId is null)
{
return(null, DatabaseDataNotFound);
}
if (typeId.Value.IsVariableAddressSimpleCheck())
{
return(null, TargetIdNotFound);
}
var refer = GetDatabaseRefer(dbKind);
var typeDescList = refer.TypeDescList;
if (typeId.Value < 0 || typeDescList.Count <= typeId.Value)
{
return(null, DatabaseDataNotFound);
}
var targetTypeDesc = typeDescList[typeId.Value];
var targetDataDesc = targetTypeDesc.DataDescList
.Select((x, idx) => (idx, x.DataName))
.FirstOrDefault(y => y.DataName.Equals(dataName));
if (targetDataDesc == default((int, DataName)))
{
return(null, TargetIdNotFound);
}
return(targetDataDesc.idx, targetDataDesc.idx.ToString());
}
public object ExecuteScalar(string Query, DBKind kind)
{
object res;
using (var cmd = GetCommand(Query, kind))
{
try
{
cmd.Connection.Open();
res = cmd.ExecuteScalar();
}
finally
{
cmd.Connection.Close();
}
}
return(res);
}
public static void ConstructorBTest(DBDataSettingType type, DBKind dbKind,
TypeId?typeId, bool isError)
{
var errorOccured = false;
try
{
var _ = new DBDataSetting(type, dbKind, typeId);
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーフラグが一致すること
Assert.AreEqual(errorOccured, isError);
}
protected TestServerFixture(string relativeTargetProjectParentDir)
{
var startupAssembly = typeof(TStartup).GetTypeInfo().Assembly;
var contentRoot = GetProjectPath(relativeTargetProjectParentDir, startupAssembly);
Directory.SetCurrentDirectory(contentRoot);
var builder = new WebHostBuilder()
.UseContentRoot(contentRoot)
.ConfigureServices(InitializeServices)
.UseEnvironment("Development")
.UseStartup(typeof(TStartup))
//.UseApplicationInsights()
;
_server = new TestServer(builder);
Client = _server.CreateClient();
Client.BaseAddress = new Uri("http://localhost");
var configuration = _server.Host.Services.GetService(typeof(IConfiguration)) as IConfiguration;
AppRootPath = configuration?["AppRootPath"];
DBKind = configuration?["DBKind"];
ImageDirectory = configuration?["ImageDirectory"];
LiveWebCamURL = configuration?["LiveWebCamURL"];
string temp = Environment.GetEnvironmentVariable("DOTNET_RUNNING_IN_CONTAINER");
DOTNET_RUNNING_IN_CONTAINER = !string.IsNullOrEmpty(temp) && temp.Equals(true.ToString(), StringComparison.InvariantCultureIgnoreCase);
//Console.WriteLine($"### temp = {temp}, DOTNET_RUNNING_IN_CONTAINER = {DOTNET_RUNNING_IN_CONTAINER}");
var db = _server.Host.Services.GetRequiredService <EFGetStarted.AspNetCore.ExistingDb.Models.BloggingContext>();
if (DBKind.Equals("sqlite", StringComparison.InvariantCultureIgnoreCase))
{
db.Database.Migrate();
}
else
{
db.Database.EnsureCreated();
}
}
// _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
// Private Method
// _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
/// <summary>
/// DBマージデータの参照を取得する。
/// </summary>
/// <param name="dbKind">[NotNull] DB種別</param>
/// <returns>DBマージデータ</returns>
/// <exception cref="InvalidOperationException">意図しない処理の場合</exception>
private DatabaseMergedData GetDatabaseRefer(DBKind dbKind)
{
if (dbKind == DBKind.Changeable)
{
return(Master.ChangeableDatabase);
}
if (dbKind == DBKind.User)
{
return(Master.UserDatabase);
}
if (dbKind == DBKind.System)
{
return(Master.SystemDatabase);
}
// 通常ここへは来ない
throw new InvalidOperationException();
}
public static string CreateConnectionStringDotNet(DBKind dbKind, string server, string database, DBAuthenticationType dbAuthType, string user,
string password)
{
string connFormat = null;
switch (dbAuthType)
{
case DBAuthenticationType.IntegratedAuth:
connFormat = IntegratedAuthPart;
//Windows Authentication with dbKind == DBKind.Oracle is currently UNTESTED and UNSUPPORTED
break;
case DBAuthenticationType.DBAuth:
connFormat = DBAuthPart;
break;
default:
throw (new InvalidOperationException("Unknown Authentication Type : " + dbAuthType));
}
switch (dbKind)
{
case DBKind.SqlServer:
connFormat += (database == null ? ConnString_MSSQL_NoDB : ConnString_MSSQL);
break;
case DBKind.Oracle:
connFormat += ConnString_Oracle;
break;
default:
throw (new InvalidOperationException("Unknown Database Kind : " + dbKind));
}
var sqlConnectionStringBuilder = new SqlConnectionStringBuilder();
sqlConnectionStringBuilder["password"] = password ?? string.Empty;
password = sqlConnectionStringBuilder.ConnectionString.Substring("Password=".Length);
return(string.Format(connFormat, user, password, server, database));
}
public static string CreateConnectionStringJava(DBKind dbKind, DBDatasourceKind datasourceType, string datasource, string dbServer, string dbPort, string user, string password)
{
#if !JAVA
throw new InvalidOperationException();
#else
switch (datasourceType)
{
case DBDatasourceKind.Sid:
return(string.Format(ConnString_OracleJDBC_SID, user, password, dbServer, dbPort, datasource));
case DBDatasourceKind.ServiceName:
return(string.Format(ConnString_OracleJDBC_ServiceName, user, password, dbServer, dbPort, datasource));
case DBDatasourceKind.TnsName:
return(string.Format(ConnString_OracleJDBC_TnsName, user, password, datasource));
default:
throw new InvalidOperationException("Invalid datasource type: " + datasourceType.ToString());
}
#endif
}
/// <summary>
/// データIDの設定方法
/// </summary>
/// <param name="readStatus">読み込み経過状態</param>
/// <param name="setting">結果格納インスタンス</param>
private void ReadDataSettingType(BinaryReadStatus readStatus, DBDataSetting setting)
{
var typeCode = readStatus.ReadInt();
readStatus.IncreaseIntOffset();
var settingType = DBDataSettingType.FromValue(typeCode);
// 「指定DBの指定タイプ」の場合、DB種別とタイプIDを取り出す
DBKind dbKind = null;
TypeId typeId = 0;
if (settingType == DBDataSettingType.DesignatedType)
{
dbKind = DbKindFromSettingTypeCode(typeCode);
typeId = TypeIdFromSettingTypeCode(typeCode);
}
setting.SetDataSettingType(settingType, dbKind, typeId);
}
public static void GenerateDatabaseDatTest(int listLength, DBKind dbKind)
{
var typeSettingList = CreateTypeSettingList(listLength);
var dataSettingList = CreateDataSettingList(listLength);
var instance = new DatabaseMergedData(typeSettingList, dataSettingList);
var changedPropertyList = new List <string>();
instance.PropertyChanged += (sender, args) => { changedPropertyList.Add(args.PropertyName); };
DatabaseDat result = null;
var errorOccured = false;
try
{
result = instance.GenerateDatabaseDat(dbKind);
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーが発生しないこと
Assert.IsFalse(errorOccured);
// データ数が正しいこと
Assert.AreEqual(result.SettingList.Count, listLength);
// DB種別が一致すること
Assert.AreEqual(result.DBKind, dbKind);
for (var i = 0; i < listLength; i++)
{
// 内容が一致すること
Assert.AreEqual(result.SettingList[i].TypeId, dataSettingList[i].TypeId);
}
// プロパティ変更通知が発火していないこと
Assert.AreEqual(changedPropertyList.Count, 0);
}
/// <summary>
/// タイプID、項目IDを指定してDBの項目名を取得する。
/// </summary>
/// <param name="dbKind">[NotNull] DB種別</param>
/// <param name="typeId">タイプID</param>
/// <param name="itemId">項目ID</param>
/// <returns>
/// 存在フラグと項目名。
/// 存在しない場合、専用の文字列。
/// itemId が変数アドレス値の場合、専用の文字列。
/// </returns>
/// <exception cref="ArgumentNullException">dbKindがnullの場合</exception>
public (bool, string) GetDatabaseItemName(DBKind dbKind, int?typeId,
int itemId)
{
if (dbKind is null)
{
throw new ArgumentNullException(
ErrorMessage.NotNull(nameof(dbKind)));
}
if (typeId is null)
{
return(false, DatabaseDataNotFound);
}
if (itemId.IsVariableAddressSimpleCheck())
{
return(true, TargetIdVariableAddress);
}
var refer = GetDatabaseRefer(dbKind);
var typeDescList = refer.TypeDescList;
if (typeId.Value < 0 || typeDescList.Count <= typeId.Value)
{
return(false, DatabaseDataNotFound);
}
var typeDesc = typeDescList[typeId.Value];
var itemDescList = typeDesc.ItemDescList;
if (itemId < 0 || itemDescList.Count <= itemId)
{
return(false, DatabaseDataNotFound);
}
return(true, itemDescList[itemId].ItemName);
}
public static void SetDatabaseReferTest(DBKind dbKind, int dbTypeId, bool isError)
{
var typeId = (TypeId)dbTypeId;
var instance = new CommonEventSpecialNumberArgDesc.InnerDescDatabase();
var changedPropertyList = new List <string>();
instance.PropertyChanged += (sender, args) => { changedPropertyList.Add(args.PropertyName); };
var errorOccured = false;
try
{
instance.SetDatabaseRefer(dbKind, typeId);
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーフラグが一致すること
Assert.AreEqual(errorOccured, isError);
// 意図したとおりプロパティ変更通知が発火していること
if (isError)
{
Assert.AreEqual(changedPropertyList.Count, 0);
}
else
{
Assert.AreEqual(changedPropertyList.Count, 2);
Assert.IsTrue(changedPropertyList[0]
.Equals(nameof(CommonEventSpecialNumberArgDesc.InnerDescDatabase.DatabaseUseDbKind)));
Assert.IsTrue(changedPropertyList[1]
.Equals(nameof(CommonEventSpecialNumberArgDesc.InnerDescDatabase.DatabaseDbTypeId)));
}
}
// _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
// Public Method
// _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
/// <summary>
/// タイプIDを指定してDBのタイプ名を取得する。
/// </summary>
/// <param name="dbKind">[NotNull] DB種別</param>
/// <param name="id">タイプID</param>
/// <returns>
/// 存在フラグとタイプ名。
/// 存在しない場合、nullであれば専用の文字列。
/// id が変数アドレス値の場合、専用の文字列。
/// </returns>
/// <exception cref="ArgumentNullException">dbKindがnullの場合</exception>
public (bool, string) GetDatabaseTypeName(DBKind dbKind, int id)
{
if (dbKind is null)
{
throw new ArgumentNullException(
ErrorMessage.NotNull(nameof(dbKind)));
}
if (id.IsVariableAddressSimpleCheck())
{
return(true, TargetIdVariableAddress);
}
var refer = GetDatabaseRefer(dbKind);
var typeDescList = refer.TypeDescList;
if (id < 0 || typeDescList.Count <= id)
{
return(false, DatabaseDataNotFound);
}
return(true, typeDescList[id].TypeName);
}
public static void DBKindGetterTest(DBDataSettingType type, bool isError)
{
var answer = DBKind.User;
var typeSetting = new DBTypeSetting();
var dataSetting = new DBDataSetting(type, answer, 0);
var instance = new DatabaseTypeDesc(typeSetting, dataSetting);
var changedPropertyList = new List <string>();
instance.PropertyChanged += (sender, args) => { changedPropertyList.Add(args.PropertyName); };
DBKind result = null;
var errorOccured = false;
try
{
result = instance.DBKind;
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーフラグが一致すること
Assert.AreEqual(errorOccured, isError);
if (!errorOccured)
{
// 取得した結果が意図した値であること
Assert.AreEqual(result, answer);
}
// プロパティ変更通知が発火していないこと
Assert.AreEqual(changedPropertyList.Count, 0);
}
private CommonEventSpecialNumberArgDesc UpdateSpecialNumberArgDesc_MakeDescForReferDatabase(
CommonEventArgType type,
string argName, int initValue, List <int> numberArgList, List <string> stringArgList)
{
var caseList = new List <CommonEventSpecialArgCase>();
for (var j = 0; j < stringArgList.Count; j++)
{
var argCase = new CommonEventSpecialArgCase(-1 * (j + 1), stringArgList[j]);
caseList.Add(argCase);
}
var desc = new CommonEventSpecialNumberArgDesc
{
ArgName = argName,
InitValue = initValue
};
desc.ChangeArgType(type, caseList);
desc.SetDatabaseRefer(DBKind.FromSpecialArgCode(numberArgList[0]), numberArgList[1]);
desc.SetDatabaseUseAdditionalItemsFlag(numberArgList[2] == 1);
return(desc);
}
public static void SetDataSettingTypeTest(DBDataSettingType type,
DBKind dbKind, TypeId?typeId, bool isError)
{
var instance = MakeInstance(DBDataSettingType.Manual);
var changedPropertyList = new List <string>();
instance.PropertyChanged += (sender, args) => { changedPropertyList.Add(args.PropertyName); };
var errorOccured = false;
try
{
instance.SetDataSettingType(type, dbKind, typeId);
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーフラグが一致すること
Assert.AreEqual(errorOccured, isError);
// 意図したとおりプロパティ変更通知が発火していること
if (errorOccured)
{
Assert.AreEqual(changedPropertyList.Count, 0);
}
else
{
Assert.AreEqual(changedPropertyList.Count, 3);
Assert.IsTrue(changedPropertyList[0].Equals(nameof(DBDataSetting.DataSettingType)));
Assert.IsTrue(changedPropertyList[1].Equals(nameof(DBDataSetting.DBKind)));
Assert.IsTrue(changedPropertyList[2].Equals(nameof(DBDataSetting.TypeId)));
}
}
