diff --git a/dotnet/DotNetStandardClasses.sln b/dotnet/DotNetStandardClasses.sln
index eeaf8caad..a974b74a0 100644
--- a/dotnet/DotNetStandardClasses.sln
+++ b/dotnet/DotNetStandardClasses.sln
@@ -188,6 +188,16 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GxXsl", "src\dotnetcore\GxXsl\GxXsl.csproj", "{30E7E437-F9B0-42B8-9144-A8E8F972B462}"
EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "mocking", "mocking", "{5045873B-E7CF-4317-94C1-0EF8623D23FA}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{8E5A25F9-2D64-4742-8227-2A3C5816AFEC}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MockDBAccess", "src\extensions\mocking\src\MockDBAccess\MockDBAccess.csproj", "{8D05D621-3DB3-459F-8665-BEA4574F4EFF}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{C16BD5A9-4412-4B91-BB70-5C88B7AAE675}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestMockDBAccess", "src\extensions\mocking\test\TestMockDBAccess\TestMockDBAccess.csproj", "{B01A243D-C012-4BEB-BAA9-E1D9AC1468C8}"
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@@ -462,6 +472,14 @@ Global
{30E7E437-F9B0-42B8-9144-A8E8F972B462}.Debug|Any CPU.Build.0 = Debug|Any CPU
{30E7E437-F9B0-42B8-9144-A8E8F972B462}.Release|Any CPU.ActiveCfg = Release|Any CPU
{30E7E437-F9B0-42B8-9144-A8E8F972B462}.Release|Any CPU.Build.0 = Release|Any CPU
+ {8D05D621-3DB3-459F-8665-BEA4574F4EFF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {8D05D621-3DB3-459F-8665-BEA4574F4EFF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {8D05D621-3DB3-459F-8665-BEA4574F4EFF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {8D05D621-3DB3-459F-8665-BEA4574F4EFF}.Release|Any CPU.Build.0 = Release|Any CPU
+ {B01A243D-C012-4BEB-BAA9-E1D9AC1468C8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {B01A243D-C012-4BEB-BAA9-E1D9AC1468C8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {B01A243D-C012-4BEB-BAA9-E1D9AC1468C8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {B01A243D-C012-4BEB-BAA9-E1D9AC1468C8}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
@@ -552,6 +570,11 @@ Global
{B59F76D8-FDB2-4F51-89DB-F15E9BDFF1DC} = {420E8A4A-11D9-42E9-BFB7-4325EA7330B8}
{D97E17A4-C945-4BF3-957E-F73142C4C6D0} = {947E032A-C385-4586-96E3-FC7D2767F082}
{30E7E437-F9B0-42B8-9144-A8E8F972B462} = {2261B65E-3757-4E5B-9DCD-EAE8D1E236A3}
+ {5045873B-E7CF-4317-94C1-0EF8623D23FA} = {C6AFB6A3-FF0B-4970-B1F1-10BCD3D932B2}
+ {8E5A25F9-2D64-4742-8227-2A3C5816AFEC} = {5045873B-E7CF-4317-94C1-0EF8623D23FA}
+ {8D05D621-3DB3-459F-8665-BEA4574F4EFF} = {8E5A25F9-2D64-4742-8227-2A3C5816AFEC}
+ {C16BD5A9-4412-4B91-BB70-5C88B7AAE675} = {5045873B-E7CF-4317-94C1-0EF8623D23FA}
+ {B01A243D-C012-4BEB-BAA9-E1D9AC1468C8} = {C16BD5A9-4412-4B91-BB70-5C88B7AAE675}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {E18684C9-7D76-45CD-BF24-E3944B7F174C}
diff --git a/dotnet/src/dotnetframework/GxClasses/Data/GXDataADO.cs b/dotnet/src/dotnetframework/GxClasses/Data/GXDataADO.cs
index c81ea55a0..9545b3719 100644
--- a/dotnet/src/dotnetframework/GxClasses/Data/GXDataADO.cs
+++ b/dotnet/src/dotnetframework/GxClasses/Data/GXDataADO.cs
@@ -3,10 +3,13 @@
using GeneXus.Cache;
using GeneXus.Configuration;
using GeneXus.Data.NTier.ADO;
+using GeneXus.Diagnostics;
using GeneXus.Management;
using GeneXus.Reorg;
+using GeneXus.Services;
using GeneXus.Utils;
using GeneXus.XML;
+using GxClasses.Helpers;
using log4net;
using System;
using System.Collections;
@@ -2394,7 +2397,8 @@ internal void AfterCreateCommand()
public class GxDataStore : IGxDataStore
{
- string id;
+ static readonly ILog log = log4net.LogManager.GetLogger(typeof(GxDataStore));
+ string id;
IGxConnection connection;
int handle;
GxDataRecord datarecord;
@@ -2482,6 +2486,29 @@ private void Initialize(IGxDataRecord db, string id, int hnd, IGxContext context
if (cfgBuf.IndexOf(',') > 0)
cfgBuf = cfgBuf.Split(',')[0];
datarecord = getDbmsDataRecord(id, cfgBuf);
+
+ if (GXServices.Instance != null)
+ {
+ GXService providerService = GXServices.Instance.Get(GXServices.DATA_ACCESS_SERVICE);
+ if (providerService != null)
+ {
+ GXLogging.Debug(log, "Loading DATA_ACCESS_SERVICE: ", providerService.ClassName);
+ try
+ {
+#if NETCORE
+ Type type = AssemblyLoader.GetType(providerService.ClassName);
+#else
+ Type type = Type.GetType(providerService.ClassName, true, true);
+#endif
+ datarecord = (GxDataRecord)Activator.CreateInstance(type, datarecord);
+
+ }
+ catch (Exception ex)
+ {
+ GXLogging.Error(log, "Error creating CustomDataRecord " + providerService.ClassName, ex);
+ }
+ }
+ }
}
else
{
diff --git a/dotnet/src/dotnetframework/GxClasses/Data/GXDataCommon.cs b/dotnet/src/dotnetframework/GxClasses/Data/GXDataCommon.cs
index fc61cc0b4..b58622674 100644
--- a/dotnet/src/dotnetframework/GxClasses/Data/GXDataCommon.cs
+++ b/dotnet/src/dotnetframework/GxClasses/Data/GXDataCommon.cs
@@ -332,7 +332,7 @@ public virtual IDataReader GetCacheDataReader(CacheItem item, bool computeSize,
{
return new GxCacheDataReader (item, computeSize, keyCache);
}
- public IsolationLevel IsolationLevelTrn
+ public virtual IsolationLevel IsolationLevelTrn
{
get{ return isolationLevel;}
set { isolationLevel=value;}
@@ -346,6 +346,12 @@ public abstract GxAbstractConnectionWrapper GetConnection(
public abstract IDbDataParameter CreateParameter(string name, Object dbtype, int gxlength, int gxdec);
+ public string BuildConnectionStringImpl(string datasourceName, string userId,
+ string userPassword, string databaseName, string port, string schema, string extra)
+ {
+ return BuildConnectionString(datasourceName, userId, userPassword, databaseName, port, schema, extra);
+ }
+
protected abstract string BuildConnectionString(string datasourceName, string userId,
string userPassword,string databaseName, string port, string schema, string extra);
@@ -421,7 +427,7 @@ public virtual void SetParameterBlob(IDbDataParameter parameter, string value, b
SetBinary(parameter, binary);
}
- protected virtual void SetBinary(IDbDataParameter parameter, byte[] binary) {
+ public virtual void SetBinary(IDbDataParameter parameter, byte[] binary) {
parameter.Value = binary;
if (binary != null)
parameter.Size = binary.Length;
@@ -471,18 +477,18 @@ public virtual void SetTimeout(IGxConnectionManager connManager, IGxConnection c
}
public virtual string SetTimeoutSentence(long milliseconds){ return null;}
- public int LockTimeout
+ public virtual int LockTimeout
{
get{ return m_lockTimeout;}
set{ m_lockTimeout=value;}
}
- public int LockRetryCount
+ public virtual int LockRetryCount
{
get{ return m_lockRetryCount;}
set{ m_lockRetryCount=value;}
}
- public string DataBaseName
+ public virtual string DataBaseName
{
get { return m_dataBaseName; }
set { m_dataBaseName = value; }
@@ -743,7 +749,7 @@ public virtual DbDataAdapterElem GetDataAdapter(IGxConnection con, string stmt,
}
return adapter;
}
- protected virtual DbDataAdapterElem GetCachedDataAdapter(IGxConnection con, string stmt)
+ public virtual DbDataAdapterElem GetCachedDataAdapter(IGxConnection con, string stmt)
{
return con.ConnectionCache.GetDataAdapter(stmt);
}
@@ -768,7 +774,7 @@ public virtual IDbCommand GetCommand(IGxConnection con, string stmt, GxParameter
{
return GetCommand(con, stmt, parameters);
}
- protected virtual void PrepareCommand(IDbCommand cmd)
+ public virtual void PrepareCommand(IDbCommand cmd)
{
}
public virtual int GetCommandTimeout()
@@ -835,12 +841,12 @@ public virtual void DisposeCommand(IDbCommand command)
command.Dispose();
}
- protected virtual IDbCommand GetCachedCommand(IGxConnection con, string stmt)
+ public virtual IDbCommand GetCachedCommand(IGxConnection con, string stmt)
{
return con.ConnectionCache.GetPreparedCommand(stmt);
}
- public string ConnectionString
+ public virtual string ConnectionString
{
get{ return m_connectionString;}
set{ m_connectionString=value;}
@@ -933,7 +939,7 @@ protected static byte[] GetBinary(string fileNameParm, bool dbBlob)
}
}
- public string DataSource
+ public virtual string DataSource
{
get {return m_datasource;}
set{m_datasource=value;}
@@ -952,7 +958,7 @@ public string ConnectionStringForLog()
}
return result;
}
- protected virtual bool hasKey(string data, string key)
+ public virtual bool hasKey(string data, string key)
{
if (!string.IsNullOrEmpty(data) && data.IndexOf(key, StringComparison.OrdinalIgnoreCase) >= 0)
{
@@ -966,7 +972,7 @@ protected virtual bool hasKey(string data, string key)
}
return false;
}
- protected virtual string ParseAdditionalData(string data, string extractWord)
+ public virtual string ParseAdditionalData(string data, string extractWord)
{
char[] sep = {';'};
StringBuilder res=new StringBuilder("");
@@ -981,7 +987,7 @@ protected virtual string ParseAdditionalData(string data, string extractWord)
}
return res.ToString();
}
- protected virtual string ReplaceKeyword(string data, string keyword, string newKeyword)
+ public virtual string ReplaceKeyword(string data, string keyword, string newKeyword)
{
char[] sep = { ';' };
StringBuilder res = new StringBuilder("");
@@ -1006,7 +1012,7 @@ protected virtual string ReplaceKeyword(string data, string keyword, string newK
}
return res.ToString();
}
- protected virtual string RemoveDuplicates(string data, string extractWord)
+ public virtual string RemoveDuplicates(string data, string extractWord)
{
char[] sep = { ';' };
StringBuilder res = new StringBuilder("");
@@ -1659,7 +1665,7 @@ internal override object CloneParameter(IDbDataParameter p)
{
return ((ICloneable)p).Clone();
}
- protected override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
+ public override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
{
if (multipleDatareadersEnabled)
{
@@ -4242,7 +4248,7 @@ public bool Read()
public virtual DateTime GetDateTime(int i)
{
if (computeSizeInBytes) readBytes += 8;
- var value = block.Item(pos,i);
+ object value = block.Item(pos,i);
if (value is DateTime)
return (DateTime)value;
diff --git a/dotnet/src/dotnetframework/GxClasses/Data/GXDataDb2.cs b/dotnet/src/dotnetframework/GxClasses/Data/GXDataDb2.cs
index adfc32bb2..3d4eb0999 100644
--- a/dotnet/src/dotnetframework/GxClasses/Data/GXDataDb2.cs
+++ b/dotnet/src/dotnetframework/GxClasses/Data/GXDataDb2.cs
@@ -505,7 +505,7 @@ internal override object CloneParameter(IDbDataParameter p)
/* db2400:the same command cannot be executed a second time without first
* close it (it is possible if they are different commands), then if it is cached,
* and it is not closed, it cannot be used, a new one is created*/
- protected override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
+ public override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
{
return con.ConnectionCache.GetAvailablePreparedCommand(stmt);
}
diff --git a/dotnet/src/dotnetframework/GxClasses/Data/GXDataDb2400.cs b/dotnet/src/dotnetframework/GxClasses/Data/GXDataDb2400.cs
index 3f73d4a36..14796df6a 100644
--- a/dotnet/src/dotnetframework/GxClasses/Data/GXDataDb2400.cs
+++ b/dotnet/src/dotnetframework/GxClasses/Data/GXDataDb2400.cs
@@ -267,7 +267,7 @@ public override bool GetBoolean(IGxDbCommand cmd, IDataRecord DR, int i)
{
return (base.GetInt(cmd, DR, i) == 1);
}
- protected override string ParseAdditionalData(string data,string extractWord)
+ public override string ParseAdditionalData(string data,string extractWord)
{
char[] sep = {';'};
StringBuilder res=new StringBuilder("");
@@ -396,7 +396,7 @@ public override void SetParameter(IDbDataParameter parameter, Object value)
}
}
- protected override void SetBinary(IDbDataParameter parameter, byte[] binary)
+ public override void SetBinary(IDbDataParameter parameter, byte[] binary)
{
GXLogging.Debug(log, "SetParameter BLOB, binary.length:" + binary != null ? binary.Length.ToString() : "null");
parameter.Value = binary;
@@ -594,7 +594,7 @@ internal override object CloneParameter(IDbDataParameter p)
, p.Scale, p.SourceColumn, p.SourceVersion, p.Value});
}
- protected override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
+ public override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
{
return con.ConnectionCache.GetAvailablePreparedCommand(stmt);
}
@@ -900,7 +900,7 @@ protected override string BuildConnectionString(string datasourceName, string us
}
- protected override string ParseAdditionalData(string data, string extractWord)
+ public override string ParseAdditionalData(string data, string extractWord)
{
char[] sep = { ';' };
StringBuilder res = new StringBuilder("");
@@ -1116,7 +1116,7 @@ internal override object CloneParameter(IDbDataParameter p)
return ((ICloneable)p).Clone();
}
- protected override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
+ public override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
{
return con.ConnectionCache.GetAvailablePreparedCommand(stmt);
}
diff --git a/dotnet/src/dotnetframework/GxClasses/Data/GXDataHana.cs b/dotnet/src/dotnetframework/GxClasses/Data/GXDataHana.cs
index 8bcd5fb2b..9842e4b16 100644
--- a/dotnet/src/dotnetframework/GxClasses/Data/GXDataHana.cs
+++ b/dotnet/src/dotnetframework/GxClasses/Data/GXDataHana.cs
@@ -247,7 +247,7 @@ public override void SetParameter(IDbDataParameter parameter, Object value)
parameter.Value = CheckDataLength(value, parameter);
}
}
- protected override void SetBinary(IDbDataParameter parameter, byte[] binary)
+ public override void SetBinary(IDbDataParameter parameter, byte[] binary)
{
GXLogging.Debug(log, "SetParameter BLOB, binary.length:" + binary.Length);
if (binary != null && binary.Length == 0)
@@ -277,7 +277,7 @@ public override string GetServerUserIdStmt()
return "CURENT_USER";
}
- protected override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
+ public override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
{
return con.ConnectionCache.GetAvailablePreparedCommand(stmt);
}
diff --git a/dotnet/src/dotnetframework/GxClasses/Data/GXDataInformix.cs b/dotnet/src/dotnetframework/GxClasses/Data/GXDataInformix.cs
index a7e4b1112..ad8129cc3 100644
--- a/dotnet/src/dotnetframework/GxClasses/Data/GXDataInformix.cs
+++ b/dotnet/src/dotnetframework/GxClasses/Data/GXDataInformix.cs
@@ -220,7 +220,7 @@ private object GXTypeToIfxType(GXType type)
}
}
- protected override void PrepareCommand(IDbCommand cmd)
+ public override void PrepareCommand(IDbCommand cmd)
{
}
@@ -450,7 +450,7 @@ internal override object CloneParameter(IDbDataParameter p)
return ((ICloneable)p).Clone();
}
- protected override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
+ public override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
{
return con.ConnectionCache.GetAvailablePreparedCommand(stmt);
}
diff --git a/dotnet/src/dotnetframework/GxClasses/Data/GXDataMysqlConnector.cs b/dotnet/src/dotnetframework/GxClasses/Data/GXDataMysqlConnector.cs
index 3fc04eab7..f3f07ee2e 100644
--- a/dotnet/src/dotnetframework/GxClasses/Data/GXDataMysqlConnector.cs
+++ b/dotnet/src/dotnetframework/GxClasses/Data/GXDataMysqlConnector.cs
@@ -260,7 +260,7 @@ public override IDataReader GetDataReader(
}
return idatareader;
}
- protected override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
+ public override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
{
return con.ConnectionCache.GetAvailablePreparedCommand(stmt);
}
diff --git a/dotnet/src/dotnetframework/GxClasses/Data/GXDataMysqlDriverCS.cs b/dotnet/src/dotnetframework/GxClasses/Data/GXDataMysqlDriverCS.cs
index 6afc6684a..6f96cda96 100644
--- a/dotnet/src/dotnetframework/GxClasses/Data/GXDataMysqlDriverCS.cs
+++ b/dotnet/src/dotnetframework/GxClasses/Data/GXDataMysqlDriverCS.cs
@@ -171,7 +171,7 @@ public override IDataReader GetDataReader(
idatareader = new GxMySQLDriverCSDataReader(connManager, this, con, parameters, stmt, fetchSize, forFirst, handle, cached, expiration, dynStmt, preparedStmts);
return idatareader;
}
- protected override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
+ public override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
{
return con.ConnectionCache.GetAvailablePreparedCommand(stmt);
}
diff --git a/dotnet/src/dotnetframework/GxClasses/Data/GXDataNTierService.cs b/dotnet/src/dotnetframework/GxClasses/Data/GXDataNTierService.cs
index 144d21f48..b8a1ff5d5 100644
--- a/dotnet/src/dotnetframework/GxClasses/Data/GXDataNTierService.cs
+++ b/dotnet/src/dotnetframework/GxClasses/Data/GXDataNTierService.cs
@@ -281,7 +281,7 @@ public override string GetServerUserIdStmt()
}
- protected override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
+ public override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
{
return con.ConnectionCache.GetAvailablePreparedCommand(stmt);
}
diff --git a/dotnet/src/dotnetframework/GxClasses/Data/GXDataOracle.cs b/dotnet/src/dotnetframework/GxClasses/Data/GXDataOracle.cs
index ab42fc3af..ea358ee2b 100644
--- a/dotnet/src/dotnetframework/GxClasses/Data/GXDataOracle.cs
+++ b/dotnet/src/dotnetframework/GxClasses/Data/GXDataOracle.cs
@@ -1179,7 +1179,7 @@ public override void SetParameter(IDbDataParameter parameter, Object value)
}
}
- protected override void SetBinary(IDbDataParameter parameter, byte[] binary)
+ public override void SetBinary(IDbDataParameter parameter, byte[] binary)
{
GXLogging.Debug(log, "SetParameter BLOB, binary.length:", () => binary != null ? binary.Length.ToString() : "null");
if (binary != null && binary.Length == 0)
diff --git a/dotnet/src/dotnetframework/GxClasses/Data/GXDataPostgreSQL.cs b/dotnet/src/dotnetframework/GxClasses/Data/GXDataPostgreSQL.cs
index 530f67247..836a138cd 100644
--- a/dotnet/src/dotnetframework/GxClasses/Data/GXDataPostgreSQL.cs
+++ b/dotnet/src/dotnetframework/GxClasses/Data/GXDataPostgreSQL.cs
@@ -270,7 +270,7 @@ public override long GetBytes(IGxDbCommand cmd, IDataRecord DR, int i, long fiel
}
}
//ByteArrayToByteaTextEscaped
- protected override void SetBinary(IDbDataParameter parameter, byte[] byteArray)
+ public override void SetBinary(IDbDataParameter parameter, byte[] byteArray)
{
if (_byteaOutputEscape)
{
diff --git a/dotnet/src/dotnetframework/GxClasses/Data/GXDataSqlite.cs b/dotnet/src/dotnetframework/GxClasses/Data/GXDataSqlite.cs
index 9ed323a8f..b060ab28b 100644
--- a/dotnet/src/dotnetframework/GxClasses/Data/GXDataSqlite.cs
+++ b/dotnet/src/dotnetframework/GxClasses/Data/GXDataSqlite.cs
@@ -97,7 +97,14 @@ public override DbDataAdapter CreateDataAdapeter()
internal override object CloneParameter(IDbDataParameter p)
{
- return ((ICloneable)p).Clone();
+ IDbDataParameter copy = this.CreateParameter();
+ copy.ParameterName = p.ParameterName;
+ copy.DbType=p.DbType;
+ copy.Value=p.Value;
+ copy.Size=p.Size;
+ copy.Precision=p.Precision;
+ copy.Scale=p.Scale;
+ return copy;
}
public override void DisposeCommand(IDbCommand command)
{
@@ -274,7 +281,7 @@ public override Object Net2DbmsDateTime(IDbDataParameter parm, DateTime dt)
}
static DateTime SQLSERVER_NULL_DATE = new DateTime(1753, 1, 1);
- protected override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
+ public override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
{
return con.ConnectionCache.GetAvailablePreparedCommand(stmt);
}
diff --git a/dotnet/src/dotnetframework/GxClasses/Services/Storage/GXServices.cs b/dotnet/src/dotnetframework/GxClasses/Services/Storage/GXServices.cs
index 28432439e..9f21859ac 100644
--- a/dotnet/src/dotnetframework/GxClasses/Services/Storage/GXServices.cs
+++ b/dotnet/src/dotnetframework/GxClasses/Services/Storage/GXServices.cs
@@ -19,6 +19,7 @@ public class GXServices
public static string STORAGE_SERVICE = "Storage";
public static string STORAGE_APISERVICE = "StorageAPI";
public static string CACHE_SERVICE = "Cache";
+ public static string DATA_ACCESS_SERVICE = "DataAccess";
public static string SESSION_SERVICE = "Session";
public static string WEBNOTIFICATIONS_SERVICE = "WebNotifications";
private static string[] SERVICES_FILE = new string[] { "CloudServices.dev.config", "CloudServices.config" };
diff --git a/dotnet/src/extensions/mocking/src/MockDBAccess/GXMockDataRecord.cs b/dotnet/src/extensions/mocking/src/MockDBAccess/GXMockDataRecord.cs
new file mode 100644
index 000000000..ff809e59f
--- /dev/null
+++ b/dotnet/src/extensions/mocking/src/MockDBAccess/GXMockDataRecord.cs
@@ -0,0 +1,493 @@
+using System;
+using System.Data;
+using System.Data.Common;
+using GeneXus.Cache;
+using GeneXus.Data;
+using GeneXus.Data.NTier.ADO;
+using GeneXus.Utils;
+
+namespace GeneXus.Data
+{
+ public class GXMockDataRecord : GxDataRecord
+ {
+ private GxDataRecord realDataRecord;
+
+ public GXMockDataRecord(GxDataRecord innerInstance)
+ {
+ realDataRecord = innerInstance;
+ }
+
+ public override bool AllowsDuplicateParameters { get => realDataRecord.AllowsDuplicateParameters; }
+
+ public override bool SupportUpdateBatchSize { get => realDataRecord.SupportUpdateBatchSize; }
+
+ public override string DataSource { get => realDataRecord.DataSource; set => realDataRecord.DataSource = value; }
+
+ public override string DataBaseName { get => realDataRecord.DataBaseName; set => realDataRecord.DataBaseName = value; }
+
+ public override string ConnectionString { get => realDataRecord.ConnectionString; set => realDataRecord.ConnectionString = value; }
+
+ public override bool MultiThreadSafe => realDataRecord.MultiThreadSafe;
+
+ public override IsolationLevel IsolationLevelTrn { get => realDataRecord.IsolationLevelTrn; set => realDataRecord.IsolationLevelTrn = value; }
+
+ public override int LockRetryCount { get => base.LockRetryCount; set => base.LockRetryCount = value; }
+
+ public override int LockTimeout { get => base.LockTimeout; set => base.LockTimeout = value; }
+
+ public override IDbCommand GetCommand(IGxConnection con, string stmt, GxParameterCollection parameters, bool isCursor, bool forFirst, bool isRpc)
+ {
+ return new GXMockDbCommand(realDataRecord.GetCommand(con, stmt, parameters, isCursor, forFirst, isRpc), parameters);
+ }
+
+ public override DbDataAdapter CreateDataAdapeter()
+ {
+ return realDataRecord.CreateDataAdapeter();
+ }
+
+ public override IDbDataParameter CreateParameter()
+ {
+ return realDataRecord.CreateParameter();
+ }
+
+ public override IDbDataParameter CreateParameter(string name, object dbtype, int gxlength, int gxdec)
+ {
+ return realDataRecord.CreateParameter(name, dbtype, gxlength, gxdec);
+ }
+
+ public override GxAbstractConnectionWrapper GetConnection(bool showPrompt, string datasourceName, string userId, string userPassword, string databaseName, string port, string schema, string extra, GxConnectionCache connectionCache)
+ {
+ return realDataRecord.GetConnection(showPrompt, datasourceName, userId, userPassword, databaseName, port, schema, extra, connectionCache);
+ }
+
+ public override IDataReader GetDataReader(IGxConnectionManager connManager, IGxConnection connection, GxParameterCollection parameters, string stmt, ushort fetchSize, bool forFirst, int handle, bool cached, SlidingTime expiration, bool hasNested, bool dynStmt)
+ {
+ return realDataRecord.GetDataReader(connManager, connection, parameters, stmt, fetchSize, forFirst, handle, cached, expiration, hasNested, dynStmt);
+ }
+
+ public override string GetServerDateTimeStmt(IGxConnection connection)
+ {
+ return realDataRecord.GetServerDateTimeStmt(connection);
+ }
+
+ public override string GetServerDateTimeStmtMs(IGxConnection connection)
+ {
+ return realDataRecord.GetServerDateTimeStmtMs(connection);
+ }
+
+ public override string GetServerUserIdStmt()
+ {
+ return realDataRecord.GetServerUserIdStmt();
+ }
+
+ public override string GetServerVersionStmt()
+ {
+ return realDataRecord.GetServerVersionStmt();
+ }
+
+ protected override string BuildConnectionString(string datasourceName, string userId, string userPassword, string databaseName, string port, string schema, string extra)
+ {
+ return realDataRecord.BuildConnectionStringImpl(datasourceName, userId, userPassword, databaseName, port, schema, extra);
+ }
+
+ public override void AddParameters(IDbCommand cmd, GxParameterCollection parameters)
+ {
+ realDataRecord.AddParameters(cmd, parameters);
+ }
+
+ public override string AfterCreateCommand(string stmt, GxParameterCollection parmBinds)
+ {
+ return realDataRecord.AfterCreateCommand(stmt, parmBinds);
+ }
+
+ public override int BatchUpdate(DbDataAdapterElem da)
+ {
+ return realDataRecord.BatchUpdate(da);
+ }
+
+ public override string ConcatOp(int pos)
+ {
+ return realDataRecord.ConcatOp(pos);
+ }
+
+ public override void CreateDataBase(string dbname, IGxConnection con)
+ {
+ realDataRecord.CreateDataBase(dbname, con);
+ }
+
+ public override DateTime Dbms2NetDate(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.Dbms2NetDate(cmd, DR, i);
+ }
+
+ public override DateTime Dbms2NetDateTime(DateTime dt, bool precision)
+ {
+ return realDataRecord.Dbms2NetDateTime(dt, precision);
+ }
+
+ public override IGeographicNative Dbms2NetGeo(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.Dbms2NetGeo(cmd, DR, i);
+ }
+
+ public override string DbmsTToC(DateTime dt)
+ {
+ return realDataRecord.DbmsTToC(dt);
+ }
+
+ public override void DisposeCommand(IDbCommand command)
+ {
+ realDataRecord.DisposeCommand(command);
+ }
+
+ public override DateTime DTFromString(string s)
+ {
+ return realDataRecord.DTFromString(s);
+ }
+
+ public override object[] ExecuteStoredProcedure(IDbCommand cmd)
+ {
+ return realDataRecord.ExecuteStoredProcedure(cmd);
+ }
+
+ public override string FalseCondition()
+ {
+ return realDataRecord.FalseCondition();
+ }
+
+ public override string GetBinary(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.GetBinary(cmd, DR, i);
+ }
+
+ public override bool GetBoolean(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.GetBoolean(cmd, DR, i);
+ }
+
+ public override byte GetByte(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.GetByte(cmd, DR, i);
+ }
+
+ public override long GetBytes(IGxDbCommand cmd, IDataRecord DR, int i, long fieldOffset, byte[] buffer, int bufferOffset, int length)
+ {
+ return realDataRecord.GetBytes(cmd, DR, i, fieldOffset, buffer, bufferOffset, length);
+ }
+
+ public override IDataReader GetCacheDataReader(CacheItem item, bool computeSize, string keyCache)
+ {
+ return realDataRecord.GetCacheDataReader(item, computeSize, keyCache);
+ }
+
+ public override IDbCommand GetCachedCommand(IGxConnection con, string stmt)
+ {
+ return realDataRecord.GetCachedCommand(con, stmt);
+ }
+
+ public override DbDataAdapterElem GetCachedDataAdapter(IGxConnection con, string stmt)
+ {
+ return realDataRecord.GetCachedDataAdapter(con, stmt);
+ }
+
+ public override IDbCommand GetCommand(IGxConnection con, string stmt, GxParameterCollection parameters)
+ {
+ return realDataRecord.GetCommand(con, stmt, parameters);
+ }
+
+ public override int GetCommandTimeout()
+ {
+ return realDataRecord.GetCommandTimeout();
+ }
+
+ public override DbDataAdapterElem GetDataAdapter(IGxConnection con, string stmt, GxParameterCollection parameters)
+ {
+ return realDataRecord.GetDataAdapter(con, stmt, parameters);
+ }
+
+ public override DbDataAdapterElem GetDataAdapter(IGxConnection con, string stmt, int batchSize, string stmtId)
+ {
+ return realDataRecord.GetDataAdapter(con, stmt, batchSize, stmtId);
+ }
+
+ public override void SetParameterDir(GxParameterCollection parameters, int num, ParameterDirection dir)
+ {
+ realDataRecord.SetParameterDir(parameters, num, dir);
+ }
+
+ public override void SetParameter(IDbDataParameter parameter, object value)
+ {
+ realDataRecord.SetParameter(parameter, value);
+ }
+
+ public override void SetParameterBlob(IDbDataParameter parameter, string value, bool dbBlob)
+ {
+ realDataRecord.SetParameterBlob(parameter, value, dbBlob);
+ }
+
+ public override void SetBinary(IDbDataParameter parameter, byte[] binary)
+ {
+ realDataRecord.SetBinary(parameter, binary);
+ }
+
+ public override object SetParameterValue(IDbDataParameter parameter, object value)
+ {
+ return realDataRecord.SetParameterValue(parameter, value);
+ }
+
+ public override void SetParameterChar(IDbDataParameter parameter, string value)
+ {
+ realDataRecord.SetParameterChar(parameter, value);
+ }
+
+ public override void SetParameterLVChar(IDbDataParameter parameter, string value, IGxDataStore datastore)
+ {
+ realDataRecord.SetParameterLVChar(parameter, value, datastore);
+ }
+
+ public override void SetParameterVChar(IDbDataParameter parameter, string value)
+ {
+ realDataRecord.SetParameterVChar(parameter, value);
+ }
+
+ public override void SetTimeout(IGxConnectionManager connManager, IGxConnection connection, int handle)
+ {
+ realDataRecord.SetTimeout(connManager, connection, handle);
+ }
+
+ public override string SetTimeoutSentence(long milliseconds)
+ {
+ return realDataRecord.SetTimeoutSentence(milliseconds);
+ }
+
+ public override short GetShort(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.GetShort(cmd, DR, i);
+ }
+
+ public override int GetInt(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.GetInt(cmd, DR, i);
+ }
+
+ public override long GetLong(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.GetLong(cmd, DR, i);
+ }
+
+ public override double GetDouble(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.GetDouble(cmd, DR, i);
+ }
+
+ public override string GetString(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.GetString(cmd, DR, i);
+ }
+
+ public override DateTime GetDateTimeMs(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.GetDateTimeMs(cmd, DR, i);
+ }
+
+ public override DateTime GetDateTime(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.GetDateTime(cmd, DR, i);
+ }
+
+ public override DateTime GetDate(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.GetDate(cmd, DR, i);
+ }
+
+ public override Guid GetGuid(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.GetGuid(cmd, DR, i);
+ }
+
+ public override IGeographicNative GetGeospatial(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.GetGeospatial(cmd, DR, i);
+ }
+
+ public override decimal GetDecimal(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.GetDecimal(cmd, DR, i);
+ }
+
+ public override object Net2DbmsDateTime(IDbDataParameter parm, DateTime dt)
+ {
+ return realDataRecord.Net2DbmsDateTime(parm, dt);
+ }
+
+ public override object Net2DbmsGeo(GXType type, IGeographicNative geo)
+ {
+ return realDataRecord.Net2DbmsGeo(type, geo);
+ }
+
+ public override bool ProcessError(int dbmsErrorCode, string emsg, GxErrorMask errMask, IGxConnection con, ref int status, ref bool retry, int retryCount)
+ {
+ return realDataRecord.ProcessError(dbmsErrorCode, emsg, errMask, con, ref status, ref retry, retryCount);
+ }
+
+ public override bool IsDBNull(IGxDbCommand cmd, IDataRecord DR, int i)
+ {
+ return realDataRecord.IsDBNull(cmd, DR, i);
+ }
+
+ public override string ToDbmsConstant(short Value)
+ {
+ return realDataRecord.ToDbmsConstant(Value);
+ }
+
+ public override string ToDbmsConstant(int Value)
+ {
+ return realDataRecord.ToDbmsConstant(Value);
+ }
+
+ public override string ToDbmsConstant(long Value)
+ {
+ return realDataRecord.ToDbmsConstant(Value);
+ }
+
+ public override string ToDbmsConstant(decimal Value)
+ {
+ return realDataRecord.ToDbmsConstant(Value);
+ }
+
+ public override string ToDbmsConstant(float Value)
+ {
+ return realDataRecord.ToDbmsConstant(Value);
+ }
+
+ public override string ToDbmsConstant(double Value)
+ {
+ return realDataRecord.ToDbmsConstant(Value);
+ }
+
+ public override string ToDbmsConstant(string Value)
+ {
+ return realDataRecord.ToDbmsConstant(Value);
+ }
+
+ public override string ToDbmsConstant(DateTime Value)
+ {
+ return realDataRecord.ToDbmsConstant(Value);
+ }
+
+ public override string ToDbmsConstant(bool Value)
+ {
+ return realDataRecord.ToDbmsConstant(Value);
+ }
+
+ public override void SetAdapterInsertCommand(DbDataAdapterElem da, IGxConnection con, string stmt, GxParameterCollection parameters)
+ {
+ realDataRecord.SetAdapterInsertCommand(da, con, stmt, parameters);
+ }
+
+ public override bool IsBlobType(IDbDataParameter idbparameter)
+ {
+ return realDataRecord.IsBlobType(idbparameter);
+ }
+
+ public override void PrepareCommand(IDbCommand cmd)
+ {
+ realDataRecord.PrepareCommand(cmd);
+ }
+
+ public override bool hasKey(string data, string key)
+ {
+ return realDataRecord.hasKey(data, key);
+ }
+
+ public override string ParseAdditionalData(string data, string extractWord)
+ {
+ return realDataRecord.ParseAdditionalData(data, extractWord);
+ }
+
+ public override string ReplaceKeyword(string data, string keyword, string newKeyword)
+ {
+ return realDataRecord.ReplaceKeyword(data, keyword, newKeyword);
+ }
+
+ public override string RemoveDuplicates(string data, string extractWord)
+ {
+ return realDataRecord.RemoveDuplicates(data, extractWord);
+ }
+
+ public override void GetValues(IDataReader reader, ref object[] values)
+ {
+ realDataRecord.GetValues(reader, ref values);
+ }
+
+ public override void SetCursorDef(CursorDef cursorDef)
+ {
+ realDataRecord.SetCursorDef(cursorDef);
+ }
+
+ public override string GetString(IGxDbCommand cmd, IDataRecord DR, int i, int size)
+ {
+ return realDataRecord.GetString(cmd, DR, i, size);
+ }
+ }
+ public class GXMockDbCommand: IDbCommand
+ {
+ IDbCommand dbCommandImpl;
+ GxParameterCollection parameters;
+ public GXMockDbCommand(IDbCommand innerInstance, GxParameterCollection parms)
+ {
+ dbCommandImpl=innerInstance;
+ parameters=parms;
+ }
+
+ public IDbConnection Connection { get => dbCommandImpl.Connection; set => dbCommandImpl.Connection=value; }
+ public IDbTransaction Transaction { get => dbCommandImpl.Transaction; set => dbCommandImpl.Transaction=value; }
+ public string CommandText { get => dbCommandImpl.CommandText; set => dbCommandImpl.CommandText=value; }
+ public int CommandTimeout { get => dbCommandImpl.CommandTimeout; set => dbCommandImpl.CommandTimeout=value; }
+ public CommandType CommandType { get => dbCommandImpl.CommandType; set => dbCommandImpl.CommandType=value; }
+
+ public IDataParameterCollection Parameters => dbCommandImpl.Parameters;
+
+ public UpdateRowSource UpdatedRowSource { get => dbCommandImpl.UpdatedRowSource; set => dbCommandImpl.UpdatedRowSource=value; }
+
+ public void Cancel()
+ {
+ dbCommandImpl.Cancel();
+ }
+
+ public IDbDataParameter CreateParameter()
+ {
+ return dbCommandImpl.CreateParameter();
+ }
+
+ public void Dispose()
+ {
+ dbCommandImpl.Dispose();
+ }
+
+ public int ExecuteNonQuery()
+ {
+ return dbCommandImpl.ExecuteNonQuery();
+ }
+
+ public IDataReader ExecuteReader()
+ {
+ return dbCommandImpl.ExecuteReader();
+ }
+
+ public IDataReader ExecuteReader(CommandBehavior behavior)
+ {
+ return dbCommandImpl.ExecuteReader(behavior);
+ }
+
+ public object ExecuteScalar()
+ {
+ return dbCommandImpl.ExecuteScalar();
+ }
+
+ public void Prepare()
+ {
+ dbCommandImpl.Prepare();
+ }
+ }
+}
diff --git a/dotnet/src/extensions/mocking/src/MockDBAccess/MockDBAccess.csproj b/dotnet/src/extensions/mocking/src/MockDBAccess/MockDBAccess.csproj
new file mode 100644
index 000000000..d14799d11
--- /dev/null
+++ b/dotnet/src/extensions/mocking/src/MockDBAccess/MockDBAccess.csproj
@@ -0,0 +1,18 @@
+
+
+
+ net6.0;net462
+ 618;1607;1698
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/dotnet/src/extensions/mocking/test/TestMockDBAccess/CloudServices.config b/dotnet/src/extensions/mocking/test/TestMockDBAccess/CloudServices.config
new file mode 100644
index 000000000..74c78448a
--- /dev/null
+++ b/dotnet/src/extensions/mocking/test/TestMockDBAccess/CloudServices.config
@@ -0,0 +1,8 @@
+
+
+
+ GXTEST
+ DataAccess
+ GeneXus.Data.GXMockDataRecord,MockDBAccess
+
+
\ No newline at end of file
diff --git a/dotnet/src/extensions/mocking/test/TestMockDBAccess/MockTest.cs b/dotnet/src/extensions/mocking/test/TestMockDBAccess/MockTest.cs
new file mode 100644
index 000000000..4fb7c6adf
--- /dev/null
+++ b/dotnet/src/extensions/mocking/test/TestMockDBAccess/MockTest.cs
@@ -0,0 +1,21 @@
+using GeneXus.Programs;
+using NUnit.Framework;
+
+namespace TestMockDBAccess
+{
+ public class Tests
+ {
+ [SetUp]
+ public void Setup()
+ {
+ }
+
+ [Test]
+ public void TestServerDateWithMockDB()
+ {
+ //Connect to sample DB from https://www.sqlitetutorial.net/sqlite-sample-database/
+ new aabmtest().executeCmdLine(null) ;
+
+ }
+ }
+}
\ No newline at end of file
diff --git a/dotnet/src/extensions/mocking/test/TestMockDBAccess/TestMockDBAccess.csproj b/dotnet/src/extensions/mocking/test/TestMockDBAccess/TestMockDBAccess.csproj
new file mode 100644
index 000000000..4e0c1d813
--- /dev/null
+++ b/dotnet/src/extensions/mocking/test/TestMockDBAccess/TestMockDBAccess.csproj
@@ -0,0 +1,38 @@
+
+
+
+ net6.0
+ false
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ PreserveNewest
+
+
+ PreserveNewest
+
+
+ PreserveNewest
+
+
+ PreserveNewest
+
+
+
+
diff --git a/dotnet/src/extensions/mocking/test/TestMockDBAccess/aabmtest.cs b/dotnet/src/extensions/mocking/test/TestMockDBAccess/aabmtest.cs
new file mode 100644
index 000000000..6fb638eb4
--- /dev/null
+++ b/dotnet/src/extensions/mocking/test/TestMockDBAccess/aabmtest.cs
@@ -0,0 +1,223 @@
+using System;
+using System.Threading;
+using GeneXus.Application;
+using GeneXus.Data;
+using GeneXus.Data.ADO;
+using GeneXus.Data.NTier;
+using GeneXus.Data.NTier.ADO;
+using GeneXus.Procedure;
+using GeneXus.Utils;
+namespace GeneXus.Programs
+{
+ public class aabmtest : GXProcedure
+ {
+
+ public int executeCmdLine( string[] args )
+ {
+ execute();
+ return 0 ;
+ }
+
+ public aabmtest( )
+ {
+ context = new GxContext( );
+ DataStoreUtil.LoadDataStores( context);
+ dsDefault = context.GetDataStore("Default");
+ IsMain = true;
+ context.SetDefaultTheme("Carmine");
+ }
+
+ public aabmtest( IGxContext context )
+ {
+ this.context = context;
+ IsMain = false;
+ dsDefault = context.GetDataStore("Default");
+ }
+
+ public void execute( )
+ {
+ initialize();
+ executePrivate();
+ }
+
+ public void executeSubmit( )
+ {
+ aabmtest objaabmtest;
+ objaabmtest = new aabmtest();
+ objaabmtest.context.SetSubmitInitialConfig(context);
+ objaabmtest.initialize();
+ ThreadPool.QueueUserWorkItem( PropagateCulture(new WaitCallback( executePrivateCatch )),objaabmtest);
+ }
+
+ void executePrivateCatch( object stateInfo )
+ {
+ try
+ {
+ ((aabmtest)stateInfo).executePrivate();
+ }
+ catch ( Exception e )
+ {
+ GXUtil.SaveToEventLog( "Design", e);
+ Console.WriteLine( e.ToString() );
+ }
+ }
+
+ void executePrivate( )
+ {
+ /* GeneXus formulas */
+ /* Output device settings */
+ AV8date = DateTimeUtil.ServerDate( context, pr_default);
+ /*
+ INSERT RECORD ON TABLE genres
+
+ */
+ A3Genreid = 99;
+ A4Name = "pop";
+ /* Using cursor P000C2 */
+ pr_default.execute(0, new Object[] {A3Genreid, A4Name});
+ pr_default.close(0);
+ dsDefault.SmartCacheProvider.SetUpdated("genres");
+ if ( (pr_default.getStatus(0) == 1) )
+ {
+ context.Gx_err = 1;
+ Gx_emsg = (string)(context.GetMessage( "GXM_noupdate", ""));
+ }
+ else
+ {
+ context.Gx_err = 0;
+ Gx_emsg = "";
+ }
+ /* End Insert */
+ /* Optimized UPDATE. */
+ /* Using cursor P000C3 */
+ pr_default.execute(1);
+ pr_default.close(1);
+ dsDefault.SmartCacheProvider.SetUpdated("genres");
+ /* End optimized UPDATE. */
+ /* Using cursor P000C4 */
+ pr_default.execute(2);
+ while ( (pr_default.getStatus(2) != 101) )
+ {
+ A3Genreid = P000C4_A3Genreid[0];
+ A4Name = P000C4_A4Name[0];
+ context.StatusMessage( "GenreName:"+A4Name );
+ /* Exiting from a For First loop. */
+ if (true) break;
+ }
+ pr_default.close(2);
+ /* Optimized DELETE. */
+ /* Using cursor P000C5 */
+ pr_default.execute(3);
+ pr_default.close(3);
+ dsDefault.SmartCacheProvider.SetUpdated("genres");
+ /* End optimized DELETE. */
+ context.RollbackDataStores("abmtest",pr_default);
+ this.cleanup();
+ }
+
+ public override void cleanup( )
+ {
+ context.CommitDataStores("abmtest",pr_default);
+ CloseOpenCursors();
+ if ( IsMain )
+ {
+ context.CloseConnections();
+ }
+ ExitApp();
+ }
+
+ protected void CloseOpenCursors( )
+ {
+ }
+
+ public override void initialize( )
+ {
+ AV8date = DateTime.MinValue;
+ A4Name = "";
+ Gx_emsg = "";
+ P000C4_A3Genreid = new short[1] ;
+ P000C4_A4Name = new string[] {""} ;
+ pr_default = new DataStoreProvider(context, new GeneXus.Programs.aabmtest__default(),
+ new Object[][] {
+ new Object[] {
+ }
+ , new Object[] {
+ }
+ , new Object[] {
+ P000C4_A3Genreid, P000C4_A4Name
+ }
+ , new Object[] {
+ }
+ }
+ );
+ /* GeneXus formulas. */
+ context.Gx_err = 0;
+ }
+
+ private short A3Genreid ;
+ private string Gx_emsg ;
+ private DateTime AV8date ;
+ private string A4Name ;
+ private IGxDataStore dsDefault ;
+ private IDataStoreProvider pr_default ;
+ private short[] P000C4_A3Genreid ;
+ private string[] P000C4_A4Name ;
+ }
+
+ public class aabmtest__default : DataStoreHelperBase, IDataStoreHelper
+ {
+ public ICursor[] getCursors( )
+ {
+ cursorDefinitions();
+ return new Cursor[] {
+ new UpdateCursor(def[0])
+ ,new UpdateCursor(def[1])
+ ,new ForEachCursor(def[2])
+ ,new UpdateCursor(def[3])
+ };
+ }
+
+ private static CursorDef[] def;
+ private void cursorDefinitions( )
+ {
+ if ( def == null )
+ {
+ Object[] prmP000C2;
+ prmP000C2 = new Object[] {
+ new ParDef("@Genreid",GXType.Int16,4,0) ,
+ new ParDef("@Name",GXType.NVarChar,120,0)
+ };
+ Object[] prmP000C3;
+ prmP000C3 = new Object[] {
+ };
+ Object[] prmP000C4;
+ prmP000C4 = new Object[] {
+ };
+ Object[] prmP000C5;
+ prmP000C5 = new Object[] {
+ };
+ def= new CursorDef[] {
+ new CursorDef("P000C2", "INSERT INTO genres (Genreid, Name) VALUES (@Genreid, @Name)", GxErrorMask.GX_NOMASK,prmP000C2)
+ ,new CursorDef("P000C3", "UPDATE genres SET Name='new pop' WHERE Genreid = 99", GxErrorMask.GX_NOMASK | GxErrorMask.GX_MASKLOOPLOCK,prmP000C3)
+ ,new CursorDef("P000C4", "SELECT Genreid, Name FROM genres WHERE Genreid = 99 ORDER BY Genreid ",false, GxErrorMask.GX_NOMASK | GxErrorMask.GX_MASKLOOPLOCK, false, this,prmP000C4,1, GxCacheFrequency.OFF ,false,true )
+ ,new CursorDef("P000C5", "DELETE FROM genres WHERE Genreid = 99", GxErrorMask.GX_NOMASK | GxErrorMask.GX_MASKLOOPLOCK,prmP000C5)
+ };
+ }
+ }
+
+ public void getResults( int cursor ,
+ IFieldGetter rslt ,
+ Object[] buf )
+ {
+ switch ( cursor )
+ {
+ case 2 :
+ ((short[]) buf[0])[0] = rslt.getShort(1);
+ ((string[]) buf[1])[0] = rslt.getVarchar(2);
+ return;
+ }
+ }
+
+ }
+
+}
diff --git a/dotnet/src/extensions/mocking/test/TestMockDBAccess/application.key b/dotnet/src/extensions/mocking/test/TestMockDBAccess/application.key
new file mode 100644
index 000000000..5f6a84812
--- /dev/null
+++ b/dotnet/src/extensions/mocking/test/TestMockDBAccess/application.key
@@ -0,0 +1,2 @@
+7E2E22D26FF2989E2444852A85E57867
+7E2E22D26FF2989E2444852A85E57867
\ No newline at end of file
diff --git a/dotnet/src/extensions/mocking/test/TestMockDBAccess/chinook.db b/dotnet/src/extensions/mocking/test/TestMockDBAccess/chinook.db
new file mode 100644
index 000000000..1b085a8f1
Binary files /dev/null and b/dotnet/src/extensions/mocking/test/TestMockDBAccess/chinook.db differ
diff --git a/dotnet/src/extensions/mocking/test/TestMockDBAccess/client.exe.config b/dotnet/src/extensions/mocking/test/TestMockDBAccess/client.exe.config
new file mode 100644
index 000000000..368f210c9
--- /dev/null
+++ b/dotnet/src/extensions/mocking/test/TestMockDBAccess/client.exe.config
@@ -0,0 +1,102 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+