public void VerifyJetCommitIdEquality()
{
var sigX = new NATIVE_SIGNATURE()
{
ulRandom = 1,
logtimeCreate = Any.Logtime,
szComputerName = "Komputer",
};
var sigY = new NATIVE_SIGNATURE()
{
ulRandom = 1,
logtimeCreate = sigX.logtimeCreate,
szComputerName = "Komputer",
};
var x = new JET_COMMIT_ID(new NATIVE_COMMIT_ID()
{
signLog = sigX,
commitId = 123,
});
var y = new JET_COMMIT_ID(new NATIVE_COMMIT_ID()
{
signLog = sigY,
commitId = 123,
});
TestEquals(x, y);
Assert.IsTrue(x == y);
Assert.IsFalse(x != y);
}
public void VerifyJetCommitIdEqualityToNullIsFalse()
{
var sigX = new NATIVE_SIGNATURE()
{
ulRandom = 1,
logtimeCreate = Any.Logtime,
szComputerName = "Komputer",
};
var x = new JET_COMMIT_ID(new NATIVE_COMMIT_ID()
{
signLog = sigX,
commitId = 123,
});
Assert.IsFalse(x == null);
Assert.AreEqual(1, x.CompareTo(null));
var commitZero = new JET_COMMIT_ID(new NATIVE_COMMIT_ID()
{
signLog = sigX,
commitId = 0,
});
Assert.AreEqual(0, commitZero.CompareTo(null));
}
public void VerifyJetCommitIdThrowsExceptionWithInequalSignatures()
{
var sigX = new NATIVE_SIGNATURE()
{
ulRandom = 1,
logtimeCreate = Any.Logtime,
szComputerName = "Komputer",
};
var sigDifferent = new NATIVE_SIGNATURE()
{
ulRandom = 7777,
logtimeCreate = Any.Logtime,
szComputerName = "Different!",
};
var x = new JET_COMMIT_ID(new NATIVE_COMMIT_ID()
{
signLog = sigX,
commitId = 789,
});
var y = new JET_COMMIT_ID(new NATIVE_COMMIT_ID()
{
signLog = sigDifferent,
commitId = 789,
});
Assert.AreNotEqual(0, x.CompareTo(y));
}
/// <summary>
/// Test callback method
/// </summary>
/// <param name="instance">Current instance.</param>
/// <param name="commitId">Commit id seen.</param>
/// <param name="grbit">Grbit - reserved.</param>
/// <returns>Success or error.</returns>
private JET_err TestFlushCallback(
JET_INSTANCE instance,
JET_COMMIT_ID commitId,
DurableCommitCallbackGrbit grbit)
{
return(JET_err.Success);
}
/// <summary>
/// Commits the changes made to the state of the database during the current save point
/// and migrates them to the previous save point. If the outermost save point is committed
/// then the changes made during that save point will be committed to the state of the
/// database and the session will exit the transaction.
/// </summary>
/// <param name="sesid">The session to commit the transaction for.</param>
/// <param name="grbit">Commit options.</param>
/// <param name="durableCommit">Duration to commit lazy transaction.</param>
/// <param name="commitId">Commit-id associated with this commit record.</param>
public static void JetCommitTransaction2(
JET_SESID sesid,
CommitTransactionGrbit grbit,
TimeSpan durableCommit,
out JET_COMMIT_ID commitId)
{
Api.Check(Api.Impl.JetCommitTransaction2(sesid, grbit, durableCommit, out commitId));
}
public void VerifyJetCommitIdIncomparable()
{
DateTime d = DateTime.Now;
JET_COMMIT_ID commitId1 = DurableCommitTests.CreateJetCommitId(1, d, "computer", 3);
JET_COMMIT_ID commitId2 = DurableCommitTests.CreateJetCommitId(2, d, "computer", 3);
Assert.IsTrue(commitId1.GetHashCode() != commitId2.GetHashCode());
Assert.IsFalse(commitId1 == commitId2);
}
/// <summary>
/// Test callback method
/// </summary>
/// <param name="instance">Current instance.</param>
/// <param name="commitId">Commit id seen.</param>
/// <param name="grbit">Grbit - reserved.</param>
/// <returns>Success or error.</returns>
private JET_err TestCallback(
JET_INSTANCE instance,
JET_COMMIT_ID commitId,
DurableCommitCallbackGrbit grbit)
{
this.lastCommitIdFlushed = commitId;
this.lastCallbackTime = DateTime.Now;
return(JET_err.Success);
}
/// <summary>
/// Commit a transaction. This object should be in a transaction.
/// </summary>
/// <param name="grbit">JetCommitTransaction options.</param>
/// <param name="durableCommit">Duration for committing lazy transactions.</param>
/// <param name="commitId">Commit-id for this commit record.</param>
public void Commit(CommitTransactionGrbit grbit, TimeSpan durableCommit, out JET_COMMIT_ID commitId)
{
this.CheckObjectIsNotDisposed();
if (!this.IsInTransaction)
{
throw new InvalidOperationException("Not in a transaction");
}
Windows8.Windows8Api.JetCommitTransaction2(this.sesid, grbit, durableCommit, out commitId);
this.ResourceWasReleased();
Debug.Assert(!this.IsInTransaction, "Commit finished, but object is still in a transaction");
}
public void JetCommitIdToString()
{
DateTime d = DateTime.Now;
JET_COMMIT_ID commitId = DurableCommitTests.CreateJetCommitId(1, d, "computer", 2);
var signature = new JET_SIGNATURE(1, d, "computer");
string sigString = signature.ToString();
string expected = string.Format(
CultureInfo.InvariantCulture,
string.Format("JET_COMMIT_ID({0}:2", sigString));
Assert.AreEqual(expected, commitId.ToString());
}
public void VerifyJetCommitIdEquality()
{
DateTime d = DateTime.Now;
JET_COMMIT_ID commitId1 = DurableCommitTests.CreateJetCommitId(1, d, "computer", 2);
JET_COMMIT_ID commitId2 = DurableCommitTests.CreateJetCommitId(1, d, "computer", 2);
Assert.IsTrue(commitId1 == commitId2);
Assert.IsTrue(commitId1.GetHashCode() == commitId2.GetHashCode());
Assert.IsTrue(commitId1.Equals(commitId2));
Assert.IsFalse(commitId1 != commitId2);
Assert.IsTrue(commitId1 <= commitId2);
Assert.IsFalse(commitId1 < commitId2);
Assert.IsTrue(commitId1 >= commitId2);
Assert.IsFalse(commitId1 > commitId2);
}
/// <summary>
/// Commits the changes made to the state of the database during the current save point
/// and migrates them to the previous save point. If the outermost save point is committed
/// then the changes made during that save point will be committed to the state of the
/// database and the session will exit the transaction.
/// </summary>
/// <param name="sesid">The session to commit the transaction for.</param>
/// <param name="grbit">Commit options.</param>
/// <param name="durableCommit">Duration to commit lazy transaction.</param>
/// <param name="commitId">Commit-id associated with this commit record.</param>
/// <returns>An error if the call fails.</returns>
public int JetCommitTransaction2(JET_SESID sesid, CommitTransactionGrbit grbit, TimeSpan durableCommit, out JET_COMMIT_ID commitId)
{
TraceFunctionCall("JetCommitTransaction2");
this.CheckSupportsWindows8Features("JetCommitTransaction2");
int err;
uint cmsecDurableCommit = (uint)durableCommit.TotalMilliseconds;
NATIVE_COMMIT_ID nativeCommitId = new NATIVE_COMMIT_ID();
unsafe
{
err = Err(NativeMethods.JetCommitTransaction2(sesid.Value, unchecked((uint)grbit), cmsecDurableCommit, ref nativeCommitId));
}
commitId = new JET_COMMIT_ID(nativeCommitId);
return err;
}
public void VerifyJetCommitIdEqualityToWrongTypeIsFalse()
{
var sigX = new NATIVE_SIGNATURE()
{
ulRandom = 1,
logtimeCreate = Any.Logtime,
szComputerName = "Komputer",
};
var x = new JET_COMMIT_ID(new NATIVE_COMMIT_ID()
{
signLog = sigX,
commitId = 123,
});
Assert.IsFalse(x.Equals(sigX));
}
/// <summary>
/// Commits the changes made to the state of the database during the current save point
/// and migrates them to the previous save point. If the outermost save point is committed
/// then the changes made during that save point will be committed to the state of the
/// database and the session will exit the transaction.
/// </summary>
/// <param name="sesid">The session to commit the transaction for.</param>
/// <param name="grbit">Commit options.</param>
/// <param name="durableCommit">Duration to commit lazy transaction.</param>
/// <param name="commitId">Commit-id associated with this commit record.</param>
/// <returns>An error if the call fails.</returns>
public int JetCommitTransaction2(JET_SESID sesid, CommitTransactionGrbit grbit, TimeSpan durableCommit, out JET_COMMIT_ID commitId)
{
TraceFunctionCall();
this.CheckSupportsWindows8Features("JetCommitTransaction2");
int err;
uint cmsecDurableCommit = (uint)durableCommit.TotalMilliseconds;
NATIVE_COMMIT_ID nativeCommitId = new NATIVE_COMMIT_ID();
unsafe
{
err = Err(NativeMethods.JetCommitTransaction2(sesid.Value, unchecked ((uint)grbit), cmsecDurableCommit, ref nativeCommitId));
}
commitId = new JET_COMMIT_ID(nativeCommitId);
return(err);
}
public void Setup()
{
var sigX = new NATIVE_SIGNATURE()
{
ulRandom = 1,
logtimeCreate = Any.Logtime,
szComputerName = "Komputer",
};
this.managedOriginal = new JET_COMMIT_ID(new NATIVE_COMMIT_ID()
{
signLog = sigX,
commitId = 123,
});
this.native = this.managedOriginal.GetNativeCommitId();
this.managed = new JET_COMMIT_ID(this.native);
}
/// <summary>
/// The proxy callback function to call the user-defined managed delegate.
/// </summary>
/// <param name="instance">
/// The instance.
/// </param>
/// <param name="commitIdSeen">
/// The commit-id flushed.
/// </param>
/// <param name="grbit">
/// Reserved currently.
/// </param>
/// <returns>
/// An error code.
/// </returns>
private JET_err NativeDurableCommitCallback(
IntPtr instance,
ref NATIVE_COMMIT_ID commitIdSeen,
uint grbit)
{
RuntimeHelpers.PrepareConstrainedRegions();
try
{
JET_INSTANCE jetInstance = new JET_INSTANCE()
{
Value = instance
};
if (this.instance != jetInstance)
{
// We assume it's only called on one instance at a time. The only thing
// we really care about is serialization of the byte array.
//
// It would be nice to throw an error, but we're going back to real
// code, which doesn't deal with managed exceptions well.
return JET_err.CallbackFailed;
}
JET_COMMIT_ID commitId = new JET_COMMIT_ID(commitIdSeen);
return this.wrappedCallback(jetInstance, commitId, (DurableCommitCallbackGrbit)grbit);
}
catch (Exception ex)
{
Trace.WriteLineIf(
TraceSwitch.TraceWarning, string.Format(CultureInfo.InvariantCulture, "Caught Exception {0}", ex));
JetApi.ReportUnhandledException(ex, "Unhandled exception during NativeDurableCommitCallback");
// This should never be executed, but the compiler doesn't know it.
return JET_err.CallbackFailed;
}
}
/// <summary>
/// Commit a transaction. This object should be in a transaction.
/// </summary>
/// <param name="grbit">JetCommitTransaction options.</param>
/// <param name="durableCommit">Duration for committing lazy transactions.</param>
/// <param name="commitId">Commit-id for this commit record.</param>
public void Commit(CommitTransactionGrbit grbit, TimeSpan durableCommit, out JET_COMMIT_ID commitId)
{
this.CheckObjectIsNotDisposed();
if (!this.IsInTransaction)
{
throw new InvalidOperationException("Not in a transaction");
}
Windows8.Windows8Api.JetCommitTransaction2(this.sesid, grbit, durableCommit, out commitId);
this.ResourceWasReleased();
Debug.Assert(!this.IsInTransaction, "Commit finished, but object is still in a transaction");
}
