public void CreateAllErrorExceptions()
{
int i = 0;
foreach (JET_err err in Enum.GetValues(typeof(JET_err)))
{
if (JET_err.Success != err)
{
EsentErrorException ex = EsentExceptionHelper.JetErrToException(err);
Assert.IsNotNull(ex);
Assert.AreEqual(err, ex.Error);
Assert.IsNotNull(ex.Message);
Assert.AreNotEqual(string.Empty, ex.Message);
#if MANAGEDESENT_ON_CORECLR
#else
EsentErrorException deserialized = SerializeDeserialize(ex);
Assert.AreEqual(err, deserialized.Error);
Assert.AreEqual(ex.Message, deserialized.Message);
#endif
i++;
}
}
EseInteropTestHelper.ConsoleWriteLine("Created {0} different error exceptions", i);
}
public void VerifyEsentErrorExceptionSetsMessage()
{
string expected = Any.String;
var ex = new EsentErrorException(expected, JET_err.AccessDenied);
Assert.AreEqual(expected, ex.Message);
}
public EsentErrorException Verify(string logfile, byte[] logInMemory)
{
EsentErrorException ex = null;
lock (this)
{
this.AssertNotTerminated();
try
{
UnpublishedApi.ChecksumLogFromMemory(this.Sesid, logfile, this.m_basename, logInMemory);
LogChecksummer.Tracer.TraceDebug <string>((long)this.GetHashCode(), "LogChecksummer({0}) verified.", logfile);
}
catch (EsentLogFileCorruptException ex2)
{
ex = ex2;
}
catch (EsentErrorException ex3)
{
ex = ex3;
}
if (ex != null)
{
LogChecksummer.Tracer.TraceError <string, EsentErrorException>((long)this.GetHashCode(), "LogChecksummer({0}) failed:{1}", logfile, ex);
}
}
return(ex);
}
public void VerifyEsentErrorExceptionSerializationPreservesError()
{
var originalException = new EsentErrorException("description", JET_err.VersionStoreOutOfMemory);
var deserializedException = SerializeDeserialize(originalException);
Assert.AreEqual(originalException.Error, deserializedException.Error);
Assert.AreEqual(originalException.Message, deserializedException.Message);
}
// Token: 0x06001D4B RID: 7499 RVA: 0x000843F4 File Offset: 0x000825F4
internal static bool VerifyLogStatic(long logfileNumber, LogSource logSource, string logfileInspect, bool fRecopyOnFailure, FileState filestate, LogVerifier logVerifier, LogContinuityChecker continuityChecker, LogInspector.CheckStopDelegate checkStopPending, out LocalizedString error)
{
ulong num = fRecopyOnFailure ? 3UL : 1UL;
bool flag = false;
bool flag2 = false;
error = LocalizedString.Empty;
for (ulong num2 = 0UL; num2 < num; num2 += 1UL)
{
bool flag3 = false;
if (flag2 && fRecopyOnFailure)
{
LogInspector.RecopyCorruptLog(logfileNumber, logSource, logfileInspect);
flag3 = true;
}
checkStopPending();
EsentErrorException ex = logVerifier.Verify(logfileInspect);
if (ex != null)
{
ExTraceGlobals.LogInspectorTracer.TraceError <string, EsentErrorException>(0L, "Inspection of logfile {0} failed: {1}", logfileInspect, ex);
error = new LocalizedString(ex.Message);
if (!(ex is EsentFileAccessDeniedException))
{
flag2 = true;
LogInspector.ReportCorruptLog(logfileInspect, error);
}
}
else
{
flag2 = false;
checkStopPending();
flag = LogInspector.CheckLogHeader(logfileNumber, logfileInspect, filestate, continuityChecker, out error);
if (!flag)
{
LogInspector.ReportCorruptLog(logfileInspect, error);
}
else
{
if (flag3)
{
ReplayEventLogConstants.Tuple_InspectorFixedCorruptLog.LogEvent(logfileInspect, new object[]
{
logfileInspect
});
break;
}
break;
}
}
}
return(flag);
}
// Token: 0x06001D49 RID: 7497 RVA: 0x00084374 File Offset: 0x00082574
internal static bool VerifyLogTask(long logfileNumber, string logfileInspect, FileState fileState, LogVerifier logVerifier, LogContinuityChecker continuityChecker, out LocalizedString error)
{
error = LocalizedString.Empty;
if (logVerifier == null)
{
throw new ArgumentNullException("logVerifier");
}
EsentErrorException ex = logVerifier.Verify(logfileInspect);
if (ex != null)
{
error = new LocalizedString(ex.Message);
return(false);
}
return(LogInspector.CheckLogHeaderInternal(logfileNumber, logfileInspect, fileState, continuityChecker, out error));
}
public void VerifyEsentErrorExceptionHasDefaultErrorDescription()
{
var mocks = new MockRepository();
var mockApi = mocks.StrictMock <IJetApi>();
using (new ApiTestHook(mockApi))
{
Expect.Call(
mockApi.JetGetSystemParameter(
Arg <JET_INSTANCE> .Is.Anything,
Arg <JET_SESID> .Is.Anything,
Arg <JET_param> .Is.Equal(JET_param.ErrorToString),
ref Arg <int> .Ref(Is.Equal((int)JET_err.OutOfMemory), (int)JET_err.OutOfMemory).Dummy,
out Arg <string> .Out(null).Dummy,
Arg <int> .Is.Anything))
.Return((int)JET_err.InvalidParameter);
mocks.ReplayAll();
var ex = new EsentErrorException(JET_err.OutOfMemory);
Assert.IsTrue(!String.IsNullOrEmpty(ex.ErrorDescription));
}
}
public static Exception Verify(string fileName, string logFilePrefix, long expectedGen, JET_SIGNATURE?expectedLogSignature)
{
LogVerifier logVerifier = new LogVerifier(logFilePrefix);
EsentErrorException ex = logVerifier.Verify(fileName);
if (ex != null)
{
return(ex);
}
JET_LOGINFOMISC jet_LOGINFOMISC;
UnpublishedApi.JetGetLogFileInfo(fileName, out jet_LOGINFOMISC, JET_LogInfo.Misc2);
if ((long)jet_LOGINFOMISC.ulGeneration != expectedGen)
{
return(new FileCheckLogfileGenerationException(fileName, (long)jet_LOGINFOMISC.ulGeneration, expectedGen));
}
if (expectedLogSignature != null && !jet_LOGINFOMISC.signLog.Equals(expectedLogSignature))
{
return(new FileCheckLogfileSignatureException(fileName, jet_LOGINFOMISC.signLog.ToString(), expectedLogSignature.ToString()));
}
return(null);
}
public void VerifyEsentErrorExceptionGetsErrorDescriptionFromSystemParameter()
{
var mocks = new MockRepository();
var mockApi = mocks.StrictMock <IJetApi>();
using (new ApiTestHook(mockApi))
{
const string ExpectedDescription = "Error Description";
Expect.Call(
mockApi.JetGetSystemParameter(
Arg <JET_INSTANCE> .Is.Anything,
Arg <JET_SESID> .Is.Anything,
Arg <JET_param> .Is.Equal(JET_param.ErrorToString),
ref Arg <int> .Ref(Is.Equal((int)JET_err.OutOfMemory), (int)JET_err.OutOfMemory).Dummy,
out Arg <string> .Out(ExpectedDescription).Dummy,
Arg <int> .Is.Anything))
.Return((int)JET_err.Success);
mocks.ReplayAll();
var ex = new EsentErrorException(JET_err.OutOfMemory);
Assert.AreEqual(ExpectedDescription, ex.ErrorDescription);
}
}
public void CreateAllErrorExceptions()
{
int i = 0;
foreach (JET_err err in Enum.GetValues(typeof(JET_err)))
{
if (JET_err.Success != err)
{
EsentErrorException ex = EsentExceptionHelper.JetErrToException(err);
Assert.IsNotNull(ex);
Assert.AreEqual(err, ex.Error);
Assert.IsNotNull(ex.Message);
Assert.AreNotEqual(String.Empty, ex.Message);
EsentErrorException deserialized = SerializeDeserialize(ex);
Assert.AreEqual(err, deserialized.Error);
Assert.AreEqual(ex.Message, deserialized.Message);
i++;
}
}
Console.WriteLine("Created {0} different error exceptions", i);
}
public void VerifyEsentErrorExceptionConstructorSetsError()
{
var ex = new EsentErrorException(JET_err.AccessDenied);
Assert.AreEqual(JET_err.AccessDenied, ex.Error);
}
// Token: 0x06001D67 RID: 7527 RVA: 0x00084D0C File Offset: 0x00082F0C
private Exception VerifyLog(string fullLocalFileName, long expectedGen)
{
Exception ex = null;
try
{
ReplayStopwatch replayStopwatch = new ReplayStopwatch();
replayStopwatch.Start();
using (SafeFileHandle safeFileHandle = LogCopy.OpenLogForRead(fullLocalFileName))
{
long arg = replayStopwatch.ElapsedMilliseconds;
LogRepair.Tracer.TracePerformance <string, long>((long)this.GetHashCode(), "VerifyLog({0}): Open took: {1} ms", fullLocalFileName, arg);
using (FileStream fileStream = LogCopy.OpenFileStream(safeFileHandle, true))
{
FileInfo fileInfo = new FileInfo(fullLocalFileName);
long elapsedMilliseconds;
try
{
if (fileInfo.Length != 1048576L)
{
throw new IOException(string.Format("Unexpected log file size: '{0}' has 0x{1:X} bytes.", fullLocalFileName, fileInfo.Length));
}
elapsedMilliseconds = replayStopwatch.ElapsedMilliseconds;
int num = fileStream.Read(this.m_verifierLogDataBuf, 0, 1048576);
if (num != 1048576)
{
LogRepair.Tracer.TraceError <int, int, string>((long)this.GetHashCode(), "VerifyLog. Expected {0} but got {1} bytes from {2}", 1048576, num, fullLocalFileName);
throw new IOException(ReplayStrings.UnexpectedEOF(fullLocalFileName));
}
arg = replayStopwatch.ElapsedMilliseconds - elapsedMilliseconds;
LogRepair.Tracer.TracePerformance <string, long>((long)this.GetHashCode(), "VerifyLog({0}): Read took: {1} ms", fullLocalFileName, arg);
}
catch (IOException ex2)
{
throw new CorruptLogDetectedException(fullLocalFileName, ex2.Message, ex2);
}
elapsedMilliseconds = replayStopwatch.ElapsedMilliseconds;
EsentErrorException ex3 = this.EseLogVerifier.Verify(fullLocalFileName, this.m_verifierLogDataBuf);
if (ex3 != null)
{
LogRepair.Tracer.TraceError <string, EsentErrorException>((long)this.GetHashCode(), "ESELogVerifier({0}) failed: {1}", fullLocalFileName, ex3);
if (ex3 is EsentLogFileCorruptException)
{
throw new CorruptLogDetectedException(fullLocalFileName, ex3.Message, ex3);
}
throw ex3;
}
else
{
JET_LOGINFOMISC jet_LOGINFOMISC;
UnpublishedApi.JetGetLogFileInfo(fullLocalFileName, out jet_LOGINFOMISC, JET_LogInfo.Misc2);
if ((long)jet_LOGINFOMISC.ulGeneration != expectedGen)
{
throw new FileCheckLogfileGenerationException(fullLocalFileName, (long)jet_LOGINFOMISC.ulGeneration, expectedGen);
}
if (this.m_logfileSignature == null)
{
this.m_logfileSignature = new JET_SIGNATURE?(jet_LOGINFOMISC.signLog);
}
if (!jet_LOGINFOMISC.signLog.Equals(this.m_logfileSignature))
{
throw new FileCheckLogfileSignatureException(fullLocalFileName, jet_LOGINFOMISC.signLog.ToString(), this.m_logfileSignature.ToString());
}
arg = replayStopwatch.ElapsedMilliseconds - elapsedMilliseconds;
LogRepair.Tracer.TracePerformance <string, long>((long)this.GetHashCode(), "VerifyLog({0}): Verify took: {1} ms", fullLocalFileName, arg);
return(null);
}
}
}
}
catch (IOException ex4)
{
ex = ex4;
}
catch (UnauthorizedAccessException ex5)
{
ex = ex5;
}
catch (EsentErrorException ex6)
{
ex = ex6;
}
catch (CorruptLogDetectedException ex7)
{
ex = ex7;
}
catch (FileCheckException ex8)
{
ex = ex8;
}
if (ex != null)
{
LogRepair.Tracer.TraceError <string, Exception>((long)this.GetHashCode(), "VerifyLog({0}): failed with {1}", fullLocalFileName, ex);
}
return(ex);
}
