public bool PosTest1()
{
bool retVal = true;
const string c_TEST_ID = "P001";
string c_TEST_DESC = "PosTest1: initialize an instance of type AmbiguousMatchException via default constructor";
string errorDesc;
TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
try
{
AmbiguousMatchException e = new AmbiguousMatchException();
if (null == e)
{
errorDesc = "Failed to initialize an instance of type AmbiguousMatchException via default constructor.";
TestLibrary.TestFramework.LogError("001" + " TestId-" + c_TEST_ID, errorDesc);
retVal = false;
}
}
catch (Exception e)
{
errorDesc = "Unexpected exception: " + e;
TestLibrary.TestFramework.LogError("002" + " TestId-" + c_TEST_ID, errorDesc);
retVal = false;
}
return retVal;
}
public void ConstructorWithMessageAndInnerExceptionWorks() {
var inner = new Exception("a");
var ex = new AmbiguousMatchException("The message", inner);
Assert.IsTrue((object)ex is AmbiguousMatchException, "is AmbiguousMatchException");
Assert.IsTrue(ReferenceEquals(ex.InnerException, inner), "InnerException");
Assert.AreEqual(ex.Message, "The message");
}
public bool PosTest1()
{
bool retVal = true;
const string c_TEST_ID = "P001";
string c_TEST_DESC = "PosTest1: initialize an instance of type AmbiguousMatchException using an emtpy string message";
string errorDesc;
string message = string.Empty;
Exception innerException = new ArgumentNullException();
TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
try
{
AmbiguousMatchException e = new AmbiguousMatchException(message, innerException);
if (null == e || e.Message != message || e.InnerException != innerException)
{
errorDesc = "Failed to initialize an instance of type AmbiguousMatchException.";
errorDesc += "\nInput message is emtpy string";
errorDesc += "\nInner exception is " + innerException;
TestLibrary.TestFramework.LogError("001" + " TestId-" + c_TEST_ID, errorDesc);
retVal = false;
}
}
catch (Exception e)
{
errorDesc = "Unexpected exception: " + e;
errorDesc += "\nInput message is emtpy string";
errorDesc += "\nInner exception is " + innerException;
TestLibrary.TestFramework.LogError("002" + " TestId-" + c_TEST_ID, errorDesc);
retVal = false;
}
return retVal;
}
public void TypePropertiesAreCorrect() {
Assert.AreEqual(typeof(AmbiguousMatchException).FullName, "ss.AmbiguousMatchException", "Name");
Assert.IsTrue(typeof(AmbiguousMatchException).IsClass, "IsClass");
Assert.AreEqual(typeof(AmbiguousMatchException).BaseType, typeof(Exception), "BaseType");
object d = new AmbiguousMatchException();
Assert.IsTrue(d is AmbiguousMatchException, "is AmbiguousMatchException");
Assert.IsTrue(d is Exception, "is Exception");
var interfaces = typeof(AmbiguousMatchException).GetInterfaces();
Assert.AreEqual(interfaces.Length, 0, "Interfaces length");
}
public sealed override bool Bind(RuntimeAssemblyName refName, bool cacheMissedLookups, out AssemblyBindResult result, out Exception exception)
{
bool foundMatch = false;
result = default(AssemblyBindResult);
exception = null;
Exception preferredException = null;
foreach (KeyValuePair <RuntimeAssemblyName, ScopeDefinitionGroup> group in ScopeGroups)
{
if (AssemblyNameMatches(refName, group.Key, ref preferredException))
{
if (foundMatch)
{
exception = new AmbiguousMatchException();
return(false);
}
foundMatch = true;
ScopeDefinitionGroup scopeDefinitionGroup = group.Value;
result.Reader = scopeDefinitionGroup.CanonicalScope.Reader;
result.ScopeDefinitionHandle = scopeDefinitionGroup.CanonicalScope.Handle;
result.OverflowScopes = scopeDefinitionGroup.OverflowScopes;
}
}
BindEcmaAssemblyName(refName, cacheMissedLookups, ref result, ref exception, ref preferredException, ref foundMatch);
if (exception != null)
{
return(false);
}
if (!foundMatch)
{
exception = preferredException ?? new FileNotFoundException(SR.Format(SR.FileNotFound_AssemblyNotFound, refName.FullName));
return(false);
}
return(true);
}
public void CheckpointStoreIsUsedByGetCheckpointAsync()
{
using var cancellationSource = new CancellationTokenSource();
var expectedException = new AmbiguousMatchException();
var partitionId = "fakePart";
var mockCheckpointStore = new Mock <CheckpointStore>();
var mockProcessor = new MockCheckpointStoreProcessor(mockCheckpointStore.Object, 100, "fakeConsumer", "fakeNamespace", "fakeHub", Mock.Of <TokenCredential>());
mockCheckpointStore
.Setup(store => store.GetCheckpointAsync(
mockProcessor.FullyQualifiedNamespace,
mockProcessor.EventHubName,
mockProcessor.ConsumerGroup,
partitionId,
cancellationSource.Token))
.ThrowsAsync(expectedException);
Assert.That(async() => await mockProcessor.InvokeGetCheckpointAsync(partitionId, cancellationSource.Token), Throws.Exception.EqualTo(expectedException));
}
partial void BindEcmaAssemblyName(RuntimeAssemblyName refName, ref AssemblyBindResult result, ref Exception exception, ref bool foundMatch)
{
lock (s_ecmaLoadedAssemblies)
{
for (int i = 0; i < s_ecmaLoadedAssemblies.Count; i++)
{
PEInfo info = s_ecmaLoadedAssemblies[i];
if (AssemblyNameMatches(refName, info.Name))
{
if (foundMatch)
{
exception = new AmbiguousMatchException();
return;
}
foundMatch = true;
result.EcmaMetadataReader = info.Reader;
}
}
}
}
public sealed override bool Bind(AssemblyName refName, out MetadataReader reader, out ScopeDefinitionHandle scopeDefinitionHandle, out IEnumerable <QScopeDefinition> overflowScopes, out Exception exception)
{
bool foundMatch = false;
reader = null;
scopeDefinitionHandle = default(ScopeDefinitionHandle);
exception = null;
overflowScopes = null;
foreach (KeyValuePair <string, ScopeDefinitionGroup> group in ScopeGroups)
{
AssemblyName defName = new AssemblyName(group.Key);
if (AssemblyNameMatches(refName, defName))
{
if (foundMatch)
{
exception = new AmbiguousMatchException();
return(false);
}
foundMatch = true;
ScopeDefinitionGroup scopeDefinitionGroup = group.Value;
reader = scopeDefinitionGroup.CanonicalScope.Reader;
scopeDefinitionHandle = scopeDefinitionGroup.CanonicalScope.Handle;
overflowScopes = scopeDefinitionGroup.OverflowScopes;
}
}
if (!foundMatch)
{
exception = new IOException(SR.Format(SR.FileNotFound_AssemblyNotFound, refName.FullName));
return(false);
}
return(true);
}
public sealed override bool Bind(AssemblyName refName, out MetadataReader reader, out ScopeDefinitionHandle scopeDefinitionHandle, out IEnumerable<QScopeDefinition> overflowScopes, out Exception exception)
{
bool foundMatch = false;
reader = null;
scopeDefinitionHandle = default(ScopeDefinitionHandle);
exception = null;
overflowScopes = null;
foreach (KeyValuePair<string, ScopeDefinitionGroup> group in ScopeGroups)
{
AssemblyName defName = new AssemblyName(group.Key);
if (AssemblyNameMatches(refName, defName))
{
if (foundMatch)
{
exception = new AmbiguousMatchException();
return false;
}
foundMatch = true;
ScopeDefinitionGroup scopeDefinitionGroup = group.Value;
reader = scopeDefinitionGroup.CanonicalScope.Reader;
scopeDefinitionHandle = scopeDefinitionGroup.CanonicalScope.Handle;
overflowScopes = scopeDefinitionGroup.OverflowScopes;
}
}
if (!foundMatch)
{
exception = new IOException(SR.Format(SR.FileNotFound_AssemblyNotFound, refName.FullName));
return false;
}
return true;
}
public bool PosTest3()
{
bool retVal = true;
const string c_TEST_ID = "P003";
string c_TEST_DESC = "PosTest3: initialize an instance of type AmbiguousMatchException using a null reference";
string errorDesc;
string message = null;
Exception innerException = new Exception();
TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
try
{
AmbiguousMatchException e = new AmbiguousMatchException(message, innerException);
if (null == e)
{
errorDesc = "Failed to initialize an instance of type AmbiguousMatchException.";
errorDesc += "\nInput message is a null reference.";
errorDesc += "\nInner exception is " + innerException;
TestLibrary.TestFramework.LogError("005" + " TestId-" + c_TEST_ID, errorDesc);
retVal = false;
}
}
catch (Exception e)
{
errorDesc = "Unexpected exception: " + e;
errorDesc += "\nInput message is a null reference.";
errorDesc += "\nInner exception is " + innerException;
TestLibrary.TestFramework.LogError("006" + " TestId-" + c_TEST_ID, errorDesc);
retVal = false;
}
return retVal;
}
partial void BindEcmaAssemblyName(RuntimeAssemblyName refName, bool cacheMissedLookups, ref AssemblyBindResult result, ref Exception exception, ref Exception preferredException, ref bool foundMatch)
{
lock (s_ecmaLoadedAssemblies)
{
for (int i = 0; i < s_ecmaLoadedAssemblies.Count; i++)
{
PEInfo info = s_ecmaLoadedAssemblies[i];
if (AssemblyNameMatches(refName, info.Name, ref preferredException))
{
if (foundMatch)
{
exception = new AmbiguousMatchException();
return;
}
result.EcmaMetadataReader = info.Reader;
foundMatch = result.EcmaMetadataReader != null;
// For failed matches, we will never be able to succeed, so return now
if (!foundMatch)
{
return;
}
}
}
if (!foundMatch)
{
try
{
// Not found in already loaded list, attempt to source assembly from disk
foreach (string filePath in FilePathsForAssembly(refName))
{
FileStream ownedFileStream = null;
PEReader ownedPEReader = null;
try
{
if (!RuntimeAugments.FileExists(filePath))
{
continue;
}
try
{
ownedFileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
}
catch (System.IO.IOException)
{
// Failure to open a file is not fundamentally an assembly load error, but it does indicate this file cannot be used
continue;
}
ownedPEReader = new PEReader(ownedFileStream);
// FileStream ownership transferred to ownedPEReader
ownedFileStream = null;
if (!ownedPEReader.HasMetadata)
{
continue;
}
MetadataReader reader = ownedPEReader.GetMetadataReader();
// Create AssemblyName from MetadataReader
RuntimeAssemblyName runtimeAssemblyName = reader.GetAssemblyDefinition().ToRuntimeAssemblyName(reader).CanonicalizePublicKeyToken();
// If assembly name doesn't match, it isn't the one we're looking for. Continue to look for more assemblies
if (!AssemblyNameMatches(refName, runtimeAssemblyName, ref preferredException))
{
continue;
}
// This is the one we are looking for, add it to the list of loaded assemblies
PEInfo peinfo = new PEInfo(runtimeAssemblyName, reader, ownedPEReader);
s_ecmaLoadedAssemblies.Add(peinfo);
// At this point the PE reader is no longer owned by this code, but is owned by the s_ecmaLoadedAssemblies list
PEReader pe = ownedPEReader;
ownedPEReader = null;
ModuleList moduleList = ModuleList.Instance;
ModuleInfo newModuleInfo = new EcmaModuleInfo(moduleList.SystemModule.Handle, pe, reader);
moduleList.RegisterModule(newModuleInfo);
foundMatch = true;
result.EcmaMetadataReader = peinfo.Reader;
break;
}
finally
{
if (ownedFileStream != null)
{
ownedFileStream.Dispose();
}
if (ownedPEReader != null)
{
ownedPEReader.Dispose();
}
}
}
}
catch (System.IO.IOException)
{ }
catch (System.ArgumentException)
{ }
catch (System.BadImageFormatException badImageFormat)
{
exception = badImageFormat;
}
// Cache missed lookups
if (cacheMissedLookups && !foundMatch)
{
PEInfo peinfo = new PEInfo(refName, null, null);
s_ecmaLoadedAssemblies.Add(peinfo);
}
}
}
}
private void UpdateActionTarget(object oldTarget, object newTarget)
{
MethodInfo targetMethodInfo = null;
// If it's being set to the initial value, ignore it
// At this point, we're executing the View's InitializeComponent method, and the ActionTarget hasn't yet been assigned
// If they've opted to throw if the target is null, then this will cause that exception.
// We'll just wait until the ActionTarget is assigned, and we're called again
if (newTarget == View.InitialActionTarget)
{
return;
}
if (newTarget == null)
{
// If it's Enable or Disable we don't do anything - CanExecute will handle this
if (this.TargetNullBehaviour == ActionUnavailableBehaviour.Throw)
{
var e = new ActionTargetNullException(String.Format("ActionTarget on element {0} is null (method name is {1})", this.Subject, this.MethodName));
this.logger.Error(e);
throw e;
}
else
{
this.logger.Info("ActionTarget on element {0} is null (method name is {1}), but NullTarget is not Throw, so carrying on", this.Subject, this.MethodName);
}
}
else
{
BindingFlags bindingFlags;
if (newTarget is Type newTargetType)
{
bindingFlags = BindingFlags.Public | BindingFlags.Static;
}
else
{
newTargetType = newTarget.GetType();
bindingFlags = BindingFlags.Public | BindingFlags.Instance;
}
try
{
targetMethodInfo = newTargetType.GetMethod(this.MethodName, bindingFlags);
if (targetMethodInfo == null)
{
this.logger.Warn("Unable to find{0} method {1} on {2}", newTarget is Type ? " static" : "", this.MethodName, newTargetType.Name);
}
else
{
this.AssertTargetMethodInfo(targetMethodInfo, newTargetType);
}
}
catch (AmbiguousMatchException e)
{
var ex = new AmbiguousMatchException(String.Format("Ambiguous match for {0} method on {1}", this.MethodName, newTargetType.Name), e);
this.logger.Error(ex);
throw ex;
}
}
this.TargetMethodInfo = targetMethodInfo;
this.OnTargetChanged(oldTarget, newTarget);
}
public void ConstructorWithMessageWorks() {
var ex = new AmbiguousMatchException("The message");
Assert.IsTrue((object)ex is AmbiguousMatchException, "is AmbiguousMatchException");
Assert.IsTrue(ex.InnerException == null, "InnerException");
Assert.AreEqual(ex.Message, "The message");
}
public sealed override bool Bind(RuntimeAssemblyName refName, out AssemblyBindResult result, out Exception exception)
{
bool foundMatch = false;
result = default(AssemblyBindResult);
exception = null;
refName = refName.CanonicalizePublicKeyToken();
// At least one real-world app calls Type.GetType() for "char" using the assembly name "mscorlib". To accomodate this,
// we will adopt the desktop CLR rule that anything named "mscorlib" automatically binds to the core assembly.
bool useMscorlibNameCompareFunc = false;
RuntimeAssemblyName compareRefName = refName;
if (refName.Name == "mscorlib")
{
useMscorlibNameCompareFunc = true;
compareRefName = AssemblyNameParser.Parse(AssemblyBinder.DefaultAssemblyNameForGetType);
}
foreach (KeyValuePair <RuntimeAssemblyName, ScopeDefinitionGroup> group in ScopeGroups)
{
bool nameMatches;
if (useMscorlibNameCompareFunc)
{
nameMatches = MscorlibAssemblyNameMatches(compareRefName, group.Key);
}
else
{
nameMatches = AssemblyNameMatches(refName, group.Key);
}
if (nameMatches)
{
if (foundMatch)
{
exception = new AmbiguousMatchException();
return(false);
}
foundMatch = true;
ScopeDefinitionGroup scopeDefinitionGroup = group.Value;
result.Reader = scopeDefinitionGroup.CanonicalScope.Reader;
result.ScopeDefinitionHandle = scopeDefinitionGroup.CanonicalScope.Handle;
result.OverflowScopes = scopeDefinitionGroup.OverflowScopes;
}
}
BindEcmaAssemblyName(refName, ref result, ref exception, ref foundMatch);
if (exception != null)
{
return(false);
}
if (!foundMatch)
{
exception = new IOException(SR.Format(SR.FileNotFound_AssemblyNotFound, refName.FullName));
return(false);
}
return(true);
}
private void InvokeProcessRequestAsync <TRequestType, TResult>(TaskCompletionSource <TResult> taskProducer, StatefulServiceExecutionContext executionContext, string methodName, Tuple <Type, Type[], object[]> methodParams)
{
Exception exception = null;
try
{
if (!typeof(IProcessHttpRequest).IsAssignableFrom(typeof(TRequestType)) &&
!typeof(IProcessTcpRequest).IsAssignableFrom(typeof(TRequestType)))
{
taskProducer.SetException(new NotSupportedException("Method not supported by the server"));
return;
}
// Get Session Information
StatefulProgramInstance instance = null;
DateTime expiryTime;
IComparable sessionId;
object sessionObj = null;
HttpListenerContext httpListenerContext = methodParams.Item3[methodParams.Item3.Length - 1] as HttpListenerContext;
if (httpListenerContext != null)
{
sessionObj = httpListenerContext.Request;
}
else
{
// For TCP we smuggle the headers in IDictionary<string, string> passed via asyncState
StreamWrapper streamWrapper = methodParams.Item3[methodParams.Item3.Length - 1] as StreamWrapper;
sessionObj = streamWrapper != null ? streamWrapper.UserData : null;
}
if (!StatefulServiceReplica <TInstance> .GetSessionInformation(sessionObj, out sessionId, out expiryTime))
{
// TODO: We do not support session expiry currently
sessionId = Helpers.GenerateUniqueId();
expiryTime = DateTime.UtcNow.AddYears(100);
}
else
{
instance = this.instanceManager.GetInstance(sessionId);
}
// Create a new instance if necessary
bool setSessionInformation = false;
bool isExpired = sessionId != null && DateTime.UtcNow > expiryTime;
if (instance == null)
{
this.CreateInstance(sessionId, null);
instance = this.instanceManager.GetInstance(sessionId);
setSessionInformation = true;
}
Action <Task> processRequestContinuation = delegate(Task task)
{
this.Invoke <StatefulServiceExecutionContext>(
(cec) =>
{
Exception exception1 = null;
try
{
if (setSessionInformation)
{
if (httpListenerContext != null)
{
sessionObj = httpListenerContext.Response;
}
else
{
// For TCP we smuggle the headers in asyncObject
sessionObj = (IDictionary <string, string>)methodParams.Item3[methodParams.Item3.Length - 1];
}
StatefulServiceReplica <TInstance> .SetSessionInformation(sessionObj, sessionId, expiryTime);
}
if (!task.IsFaulted)
{
// Get the result from either the http task or task returned by Replicable method invocation.
object result = null;
if (typeof(IProcessTcpRequest).IsAssignableFrom(typeof(TRequestType)))
{
Task <Stream> tcpResponseTask = task as Task <Stream>;
if (tcpResponseTask != null)
{
result = tcpResponseTask.Result;
}
else
{
Task <object> taskWithObj = task as Task <object>;
result = (Stream)taskWithObj.Result;
}
}
taskProducer.SetResult((TResult)result);
}
else
{
exception1 = task.Exception.InnerException ?? task.Exception;
}
if (isExpired)
{
this.DeleteInstance(sessionId);
}
}
catch (Exception e)
{
AppTrace.TraceException(e, "StatefulServiceReplicaT.InvokeProcessRequestAsync");
exception1 = e;
}
finally
{
if (exception1 != null)
{
taskProducer.SetException(exception1);
}
}
});
};
if (instance != null && !isExpired)
{
IEnumerable <ReplicableMethodInfo> matchingMethods = null;
instance.TypeInfo.TryGetMatchingMethod("ProcessRequestAsync", methodParams.Item1, methodParams.Item2, out matchingMethods);
int matchingMethodCount = matchingMethods != null?matchingMethods.Count() : 0;
if (matchingMethodCount == 1 && matchingMethods.First().Type == ReplicableMethodInfo.MethodType.AsyncTask)
{
ReplicableMethodInfo methodInfo = matchingMethods.First();
Task <Tuple <object, object[]> > asyncInvocationTask = instance.InvokeAsync(methodInfo.Methods[0], methodParams.Item3);
asyncInvocationTask.Wait();
Task task = (Task)asyncInvocationTask.Result.Item1;
task.ContinueWith(processRequestContinuation);
}
else if (matchingMethodCount > 1)
{
exception = new AmbiguousMatchException(String.Format(CultureInfo.InvariantCulture, "Multiple methods with name '{0}' matching similar parameters were found", "ProcessRequestAsync"));
}
else if (typeof(IProcessHttpRequest).IsAssignableFrom(typeof(TRequestType)))
{
((IProcessHttpRequest)instance.Instance).ProcessRequestAsync((HttpListenerContext)methodParams.Item3[0])
.ContinueWith(task => { processRequestContinuation(task); }, TaskContinuationOptions.ExecuteSynchronously);
}
else
{
((IProcessTcpRequest)instance.Instance).ProcessRequestAsync((Stream)methodParams.Item3[0])
.ContinueWith(task => { processRequestContinuation(task); }, TaskContinuationOptions.ExecuteSynchronously);
}
}
else
{
AppTrace.TraceMsg(TraceLogEventType.Warning, "StatefulServiceReplicaT.InvokeProcessRequestAsync", "Instance cannot be created for expired session cookie with session id '{0}'.", sessionId);
taskProducer.SetException(new InvalidOperationException("Instance expired. Service cannot process request"));
}
}
catch (Exception e)
{
AppTrace.TraceException(e, "StatefulServiceReplicaT.InvokeProcessRequestAsync");
exception = e;
}
finally
{
if (exception != null)
{
taskProducer.SetException(exception);
}
}
}
public bool PosTest2()
{
bool retVal = true;
const string c_TEST_ID = "P002";
string c_TEST_DESC = "PosTest2: initialize an instance of type AmbiguousMatchException using a string containing special character";
string errorDesc;
string message = "Not supported exception occurs here \n\r\0\t\v";
Exception innerException = new Exception();
TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
try
{
AmbiguousMatchException e = new AmbiguousMatchException(message, innerException);
if (null == e || e.Message != message || e.InnerException != innerException)
{
errorDesc = "Failed to initialize an instance of type AmbiguousMatchException.";
errorDesc += "\nInput message is \"" + message + "\"";
errorDesc += "\nInner exception is " + innerException;
TestLibrary.TestFramework.LogError("003" + " TestId-" + c_TEST_ID, errorDesc);
retVal = false;
}
}
catch (Exception e)
{
errorDesc = "Unexpected exception: " + e;
errorDesc += "\nInput message is \"" + message + "\"";
errorDesc += "\nInner exception is " + innerException;
TestLibrary.TestFramework.LogError("004" + " TestId-" + c_TEST_ID, errorDesc);
retVal = false;
}
return retVal;
}
public void DefaultConstructorWorks() {
var ex = new AmbiguousMatchException();
Assert.IsTrue((object)ex is AmbiguousMatchException, "is AmbiguousMatchException");
Assert.IsTrue(ex.InnerException == null, "InnerException");
Assert.AreEqual(ex.Message, "Ambiguous match.");
}
