public void ConstructorWithMessageAndInnerExceptionWorks() {
var inner = new Exception("a");
var ex = new KeyNotFoundException("The message", inner);
Assert.IsTrue((object)ex is KeyNotFoundException, "is KeyNotFoundException");
Assert.IsTrue(ReferenceEquals(ex.InnerException, inner), "InnerException");
Assert.AreEqual(ex.Message, "The message");
}
private static void LogMessage(string text)
{
var randomType = Random.Next(0, 5);
switch (randomType)
{
case 0:
var embeddedException = new NotSupportedException();
var keyNotFoundException = new KeyNotFoundException("Some wrapped message", embeddedException);
Log.Error(text, keyNotFoundException);
break;
case 1:
Log.Fatal(text);
break;
case 2:
Log.Info(text);
break;
case 3:
Log.Warn(text);
break;
default:
Log.Debug(text);
break;
}
}
public void ConstructorWithMessageWorks()
{
var ex = new KeyNotFoundException("The message");
Assert.True((object)ex is KeyNotFoundException, "is KeyNotFoundException");
Assert.AreEqual(ex.InnerException, null, "InnerException");
Assert.AreEqual(ex.Message, "The message");
}
public void DefaultConstructorWorks()
{
var ex = new KeyNotFoundException();
Assert.True((object)ex is KeyNotFoundException, "is KeyNotFoundException");
Assert.AreEqual(ex.InnerException, null, "InnerException");
Assert.AreEqual(ex.Message, "Key not found.");
}
public void TypePropertiesAreCorrect()
{
Assert.AreEqual(typeof(KeyNotFoundException).GetClassName(), "Bridge.KeyNotFoundException", "Name");
object d = new KeyNotFoundException();
Assert.True(d is KeyNotFoundException, "is KeyNotFoundException");
Assert.True(d is Exception, "is Exception");
}
public void CustomFn_ReturnsCreatedException()
{
var exception = new KeyNotFoundException("Foo");
var ex = Throws<string>.Instance.Custom(p => exception)(new Param<string>(ParamName, "some fake key"));
Assert.Equal("Foo", ex.Message);
}
public void TypePropertiesAreCorrect() {
Assert.AreEqual(typeof(KeyNotFoundException).FullName, "ss.KeyNotFoundException", "Name");
Assert.IsTrue(typeof(KeyNotFoundException).IsClass, "IsClass");
Assert.AreEqual(typeof(KeyNotFoundException).BaseType, typeof(Exception), "BaseType");
object d = new KeyNotFoundException();
Assert.IsTrue(d is KeyNotFoundException, "is KeyNotFoundException");
Assert.IsTrue(d is Exception, "is Exception");
var interfaces = typeof(KeyNotFoundException).GetInterfaces();
Assert.AreEqual(interfaces.Length, 0, "Interfaces length");
}
public static EventGenerator GetScenarioByName(string scenario)
{
EventGenerator generator;
if (!ScenarioMap.TryGetValue(scenario, out generator))
{
var ex = new KeyNotFoundException("The specified scenario, " + scenario + ", was not recognized.");
ScenarioSimulatorEventSource.Log.UnknownScenario(scenario, ex);
throw ex;
}
return generator;
}
public static MessageGenerator GetScenarioByName(string scenario)
{
MessageGenerator generator;
if (!ScenarioMap.TryGetValue(scenario, out generator))
{
var ex = new KeyNotFoundException("The specified scenario, " + scenario + ", was not recognized.");
Logger.UnknownScenario(scenario, ex);
throw ex;
}
return generator;
}
//методы
public virtual AmazonCloudFrontClient GetCloudFrontClient()
{
RegionEndpoint endpoint = RegionEndpoint.GetBySystemName(Settings.RegionEndpoint);
bool isUnknownRegion = AmazonConstansts.UNKNOWN_CREDENTIALS_REGION.Equals(
endpoint.DisplayName, StringComparison.InvariantCultureIgnoreCase);
if (isUnknownRegion)
{
string comment = string.Format("Amazon region с именем {0} не обнаружен.", endpoint);
Exception exception = new KeyNotFoundException(comment);
_logger.Exception(exception);
throw exception;
}
var client = new AmazonCloudFrontClient(Settings.AccessKey, Settings.SecretKey, endpoint);
return client;
}
protected virtual IAmazonS3 GetS3Client()
{
RegionEndpoint endpoint = RegionEndpoint.GetBySystemName(Settings.RegionEndpoint);
bool isUnknownRegion = AmazonConstansts.UNKNOWN_CREDENTIALS_REGION.Equals(
endpoint.DisplayName, StringComparison.InvariantCultureIgnoreCase);
if (isUnknownRegion)
{
string comment = string.Format(MessageResources.RegionNotFound, endpoint);
Exception exception = new KeyNotFoundException(comment);
_logger.Exception(exception);
throw exception;
}
return AWSClientFactory.CreateAmazonS3Client(
Settings.AccessKey, Settings.SecretKey, endpoint
);
}
static public void initmap() {
room pos = startroom;
roomlist.Add(startroom);
Direction randdir;
Random rand1 = new Random();
KeyNotFoundException check = new KeyNotFoundException();
item randItem;
while (true)
{
pos = randroom();
randdir = (Direction)(rand1.Next(0,3));
if (pos.adjacentRooms[randdir] == null)
{
pos.addfrom("You stand in a magnificent dining room.", "Dining Room", randdir);
pos = pos.adjacentRooms[randdir];
roomlist.Add(pos);
for(int i =0; i < 2; i++)
{
while (true)
{
randItem = randRoomItem(rand1);
if(randItem.used == false)
{
pos.roomItemAdd(randItem);
break;
}
}
}
pos = randroom();
break;
}
}
while (true)
{
pos = randroom();
randdir = (Direction)(rand1.Next() % 4);
if (pos.adjacentRooms[randdir] == null)
{
pos.addfrom("You are in a billiard room. Fun.", "Billiard Room", randdir);
pos = pos.adjacentRooms[randdir];
roomlist.Add(pos);
for (int i = 0; i < 2; i++)
{
while (true)
{
randItem = randRoomItem(rand1);
if (randItem.used == false)
{
pos.roomItemAdd(randItem);
break;
}
}
}
pos = randroom();
break;
}
}
while (true)
{
pos = randroom();
randdir = (Direction)(rand1.Next() % 4);
if (pos.adjacentRooms[randdir] == null)
{
pos.addfrom("You are in a small chapel.", "Chapel", randdir);
pos = pos.adjacentRooms[randdir];
roomlist.Add(pos);
for (int i = 0; i < 2; i++)
{
while (true)
{
randItem = randRoomItem(rand1);
if (randItem.used == false)
{
pos.roomItemAdd(randItem);
break;
}
}
}
pos = randroom();
break;
}
}
while (true)
{
pos = randroom();
randdir = (Direction)(rand1.Next() % 4);
if (pos.adjacentRooms[randdir] == null)
{
pos.addfrom("You are standing in a greenhouse.", "Greenhouse", randdir);
pos = pos.adjacentRooms[randdir];
roomlist.Add(pos);
for (int i = 0; i < 2; i++)
{
while (true)
{
randItem = randRoomItem(rand1);
if (randItem.used == false)
{
pos.roomItemAdd(randItem);
break;
}
}
}
pos = randroom();
break;
}
}
while (true)
{
pos = randroom();
randdir = (Direction)(rand1.Next() % 4);
if (pos.adjacentRooms[randdir] == null)
{
pos.addfrom("You see a beautiful garden all around you.", "Garden", randdir);
pos = pos.adjacentRooms[randdir];
roomlist.Add(pos);
for (int i = 0; i < 2; i++)
{
while (true)
{
randItem = randRoomItem(rand1);
if (randItem.used == false)
{
pos.roomItemAdd(randItem);
break;
}
}
}
pos = randroom();
break;
}
}
while (true)
{
pos = randroom();
randdir = (Direction)(rand1.Next() % 4);
if (pos.adjacentRooms[randdir] == null)
{
pos.addfrom("The entrance to a topiary maze confronts you.", "Maze", randdir);
pos = pos.adjacentRooms[randdir];
roomlist.Add(pos);
for (int i = 0; i < 2; i++)
{
while (true)
{
randItem = randRoomItem(rand1);
if (randItem.used == false)
{
pos.roomItemAdd(randItem);
break;
}
}
}
pos = randroom();
break;
}
}
while (true)
{
pos = randroom();
randdir = (Direction)(rand1.Next() % 4);
if (pos.adjacentRooms[randdir] == null)
{
pos.addfrom("You're in a subway stat-wait, nope, it's a kitchen.", "Kitchen", randdir);
pos = pos.adjacentRooms[randdir];
roomlist.Add(pos);
for (int i = 0; i < 2; i++)
{
while (true)
{
randItem = randRoomItem(rand1);
if (randItem.used == false)
{
pos.roomItemAdd(randItem);
break;
}
}
}
pos = randroom();
break;
}
}
while (true)
{
pos = randroom();
randdir = (Direction)(rand1.Next() % 4);
if (pos.adjacentRooms[randdir] == null)
{
pos.addfrom("You're in what looks like someone's bedroom.", "Bedroom", randdir);
pos = pos.adjacentRooms[randdir];
roomlist.Add(pos);
for (int i = 0; i < 2; i++)
{
while (true)
{
randItem = randRoomItem(rand1);
if (randItem.used == false)
{
pos.roomItemAdd(randItem);
break;
}
}
}
pos = randroom();
break;
}
}
while (true)
{
pos = randroom();
randdir = (Direction)(rand1.Next() % 4);
if (pos.adjacentRooms[randdir] == null)
{
pos.addfrom("You are standing in the biggest linen closet you've ever seen.", "Linen Closet", randdir);
pos = pos.adjacentRooms[randdir];
roomlist.Add(pos);
for (int i = 0; i < 2; i++)
{
while (true)
{
randItem = randRoomItem(rand1);
if (randItem.used == false)
{
pos.roomItemAdd(randItem);
break;
}
}
}
pos = randroom();
break;
}
}
while (true)
{
pos = randroom();
randdir = (Direction)(rand1.Next() % 4);
if (pos.adjacentRooms[randdir] == null)
{
pos.addfrom("Phew, you're now in a room full of garbage. Who would purposely put a room like this in their house?", "Trash Room", randdir);
pos = pos.adjacentRooms[randdir];
roomlist.Add(pos);
for (int i = 0; i < 2; i++)
{
while (true)
{
randItem = randRoomItem(rand1);
if (randItem.used == false)
{
pos.roomItemAdd(randItem);
break;
}
}
}
pos = randroom();
break;
}
}
}
/// <summary>
/// Converts method arguments, if needed.
/// <remarks>
/// Conversion is needed when Types configured for custom serialization or arguments are delegates.
/// </remarks>
/// </summary>
/// <param name="details">Invocation details</param>
private void Invoke_ConvertMethodArguments(InvocationDetails details)
{
details.DelegateParamIndexes = new Dictionary<int, DelegateInterceptor>();
for (int i = 0; i < details.ParamTypes.Length; i++)
{
var delegateParamInterceptor = details.Args[i] as DelegateInterceptor;
if (delegateParamInterceptor != null)
{
details.DelegateParamIndexes.Add(i, delegateParamInterceptor);
continue;
}
var container = details.Args[i] as CustomSerializationContainer;
if (container != null)
{
var serializationHandler = _host.SerializationHandling[container.HandledType];
if (serializationHandler == null)
{
var ex = new KeyNotFoundException(string.Format(LanguageResource.KeyNotFoundException_SerializationHandlerNotFound, container.HandledType.FullName));
_host.OnInvokeCanceled(new InvokeCanceledEventArgs() { TrackingID = details.TrackingID, CancelException = ex });
throw ex;
}
details.Args[i] = serializationHandler.Deserialize(container.DataType, container.Data);
}
}
}
public void UnLoadValuesTest()
{
var root = Param.LoadValues(Common.PathCombine(_inputBasePath, _StyleSettings));
Assert.AreNotEqual(null, root, "UnLoadValueTest expected data to load into root");
Param.UnLoadValues();
try
{
var value = Param.Value[Param.InputType];
Assert.Fail("Values available after UnLoadValues");
}
catch (Exception e)
{
var expected = new KeyNotFoundException();
Assert.AreEqual(expected.GetType(), e.GetType());
}
}
/// <summary>
/// Ruft eine bestimmte Methode einer Komponente auf und übergibt die angegebene Nachricht als Parameter.
/// Für jeden Aufruf wird temporär eine neue Instanz der Komponente erstellt.
/// </summary>
/// <param name="trackingID">Aufrufschlüssel zur Nachverfolgung</param>
/// <param name="interfaceName">Name der Komponentenschnittstelle</param>
/// <param name="delegateCorrelationSet">Korrelationssatz für die Verdrahtung bestimmter Delegaten oder Ereignisse mit entfernten Methoden</param>
/// <param name="methodName">Methodenname</param>
/// <param name="paramDefs">Parameter-Definitionen</param>
/// <param name="args">Parameter</param>
/// <returns>Rückgabewert</returns>
public object Invoke(Guid trackingID, string interfaceName, List<DelegateCorrelationInfo> delegateCorrelationSet, string methodName, ParameterInfo[] paramDefs, params object[] args)
{
// Wenn kein Schnittstellenname angegeben wurde ...
if (string.IsNullOrEmpty(interfaceName))
// Ausnahme werfen
throw new ArgumentException(LanguageResource.ArgumentException_InterfaceNameMissing, "interfaceName");
// Wenn kein Methodenname angegben wurde ...
if (string.IsNullOrEmpty(methodName))
// Ausnahme werfen
throw new ArgumentException(LanguageResource.ArgumentException_MethodNameMissing, "methodName");
// Ggf. BeforeInvoke-Abos verarbeiten
ProcessBeforeInvoke(trackingID, ref interfaceName, ref delegateCorrelationSet, ref methodName, ref args);
// Wenn für den angegebenen Schnittstellennamen keine Komponente registriert ist ...
if (!_host.ComponentRegistry.ContainsKey(interfaceName))
{
// Ausnahme erzeugen
KeyNotFoundException ex = new KeyNotFoundException(string.Format("Für die angegebene Schnittstelle '{0}' ist keine Komponente registiert.", interfaceName));
// InvokeCanceled-Ereignis feuern
_host.OnInvokeCanceled(new InvokeCanceledEventArgs() { TrackingID = trackingID, CancelException = ex });
// Ausnahme werfen
throw ex;
}
// Komponentenregistrierung abrufen
ComponentRegistration registration = _host.ComponentRegistry[interfaceName];
// Komponenteninstanz erzeugen
object instance = _host.GetComponentInstance(registration);
// Implementierungstyp abrufen
Type type = instance.GetType();
// Auflistung für Ereignisverdrahtungen
Dictionary<Guid, Delegate> wiringList = null;
// Wenn die Komponente SingleCallaktiviert ist ...
if (registration.ActivationType == ActivationType.SingleCall)
{
// Auflistung für Ereignisverdrahtungen erzeugen
wiringList = new Dictionary<Guid, Delegate>();
// Bei Bedarf Client- und Server-Komponente miteinander verdrahten
CreateClientServerWires(type, instance, delegateCorrelationSet, wiringList);
}
// Transaktionsbereich
TransactionScope scope = null;
// Kontextdaten aus dem Aufrufkontext lesen (Falls welche hinterlegt sind)
LogicalCallContextData data = CallContext.GetData("__ZyanContextData_" + _host.Name) as LogicalCallContextData;
// Wenn Kontextdaten übertragen wurden ...
if (data != null)
{
// Wenn ein Sitzungsschlüssel übertragen wurde ...
if (data.Store.ContainsKey("sessionid"))
{
// Sitzungsschlüssel lesen
Guid sessionID = (Guid)data.Store["sessionid"];
// Wenn eine Sitzung mit dem angegebenen Schlüssel existiert ...
if (_host.SessionManager.ExistSession(sessionID))
{
// Sitzung abrufen
ServerSession session = _host.SessionManager.GetSessionBySessionID(sessionID);
// Sitzung verlängern
session.Timestamp = DateTime.Now;
// Aktuelle Sitzung im Threadspeicher ablegen
ServerSession.CurrentSession = session;
}
else
{
// Ausnahme erzeugen
InvalidSessionException ex = new InvalidSessionException(string.Format("Sitzungsschlüssel '{0}' ist ungültig! Bitte melden Sie sich erneut am Server an.", sessionID.ToString()));
// InvokeCanceled-Ereignis feuern
_host.OnInvokeCanceled(new InvokeCanceledEventArgs() { TrackingID = trackingID, CancelException = ex });
// Ausnahme werfen
throw ex;
}
}
// Wenn eine Transaktion übertragen wurde ...
if (data.Store.ContainsKey("transaction"))
// Transaktionsbereich erzeugen
scope = new TransactionScope((Transaction)data.Store["transaction"]);
}
else
{
// Ausnahme erzeugen
SecurityException ex = new SecurityException(LanguageResource.SecurityException_ContextInfoMissing);
// InvokeCanceled-Ereignis feuern
_host.OnInvokeCanceled(new InvokeCanceledEventArgs() { TrackingID = trackingID, CancelException = ex });
// Ausnahme werfen
throw ex;
}
// Rückgabewert
object returnValue = null;
// Typen-Array (zur Ermittlung der passenden Signatur) erzeugen
Type[] types = new Type[paramDefs.Length];
// Auflistung der Indizes von Parametern, für die eine Delegatenverdrahtung notwendig ist
Dictionary<int,DelegateInterceptor> delegateParamIndexes=new Dictionary<int,DelegateInterceptor>();
// Alle Parametertypen durchlaufen
for (int i = 0; i < paramDefs.Length; i++)
{
// Typ in Array einfügen
types[i] = paramDefs[i].ParameterType;
// Versuchen den aktuellen Parameter in eine Delegaten-Abfangvorrichtung zu casten
DelegateInterceptor delegateParamInterceptor = args[i] as DelegateInterceptor;
// Wenn aktuelle Parameter eine Delegaten-Abfangvorrichtung ist ...
if (delegateParamInterceptor != null)
// Parameter der Delegaten-Verdrahtungsliste zufügen
delegateParamIndexes.Add(i, delegateParamInterceptor);
}
// Ausnahme-Schalter
bool exceptionThrown = false;
try
{
// Metadaten der aufzurufenden Methode abrufen
MethodInfo methodInfo = type.GetMethod(methodName, types);
// Metadaten der Parameter abrufen
ParameterInfo[] serverMethodParamDefs = methodInfo.GetParameters();
// Delegaten-Verdrahtungsliste durchlaufen
foreach(int index in delegateParamIndexes.Keys)
{
// Abfangvorrichtung adressieren
DelegateInterceptor delegateParamInterceptor = delegateParamIndexes[index];
// Metadaten des passenden Parameters der Serverkomponenten-Methode adressieren
ParameterInfo serverMethodParamDef = serverMethodParamDefs[index];
// Dynamischen Draht erzeugen
object dynamicWire = DynamicWireFactory.Instance.CreateDynamicWire(type, serverMethodParamDef.ParameterType, delegateParamInterceptor);
// Typ des dynamischen Drahtes ermitteln
Type dynamicWireType = dynamicWire.GetType();
// Dynamischen Draht mit Client-Fernsteuerung verdrahten
dynamicWireType.GetProperty("Interceptor").SetValue(dynamicWire, delegateParamInterceptor, null);
// Delegat zu dynamischem Draht erzeugen
Delegate dynamicWireDelegate = Delegate.CreateDelegate(serverMethodParamDef.ParameterType, dynamicWire, dynamicWireType.GetMethod("In"));
// Abfangvorrichtung durch dynamischen Draht austauschen
args[index] = dynamicWireDelegate;
}
// Methode aufrufen
returnValue = methodInfo.Invoke(instance, args);
}
catch (Exception ex)
{
// Ausnahme-Schalter setzen
exceptionThrown = true;
// InvokeCanceled-Ereignis feuern
_host.OnInvokeCanceled(new InvokeCanceledEventArgs() { TrackingID = trackingID, CancelException = ex });
// Ausnahme weiterwerfen
throw ex;
}
finally
{
// Wenn ein Transaktionsbereich existiert ...
if (scope != null)
{
// Wenn keine Ausnahme aufgetreten ist ...
if (!exceptionThrown)
// Transaktionsbereich abschließen
scope.Complete();
// Transaktionsbereich entsorgen
scope.Dispose();
}
// Wenn die Komponente SingleCallaktiviert ist ...
if (registration.ActivationType == ActivationType.SingleCall)
// Verdrahtung aufheben
RemoveClientServerWires(type, instance, delegateCorrelationSet, wiringList);
}
// Ggf. AfterInvoke-Abos verarbeiten
ProcessAfterInvoke(trackingID, ref interfaceName, ref delegateCorrelationSet, ref methodName, ref args, ref returnValue);
// Rückgabewert zurückgeben
return returnValue;
}
private static IAsyncResult QueryItemFromServerAsync(string key, ConfigType type, Action<ConfigItem, Exception> callback)
{
string url = new UrlBuilder()
.SetPath("/ActiveConfig/v1/GetKey")
.AddParam("appid", _appKey)
.AddParam("secretkey", _appSecret)
.AddParam("key", key + ":" + (int)type)
.GetUrl();
return Http.GetStringAsync(url, (s, e) =>
{
ConfigItem result = null;
if (e == null)
{
result = null;
try
{
var dict = JSON.Parse(s);
if (dict != null)
{
string code = dict["code"].Value;
string msg = dict["msg"].Value;
string data = dict["data"].Value;
if (code != "0")
{
Debug.WriteLine("Server return error {0}: {1}", code, msg);
e = new ActiveConfigException(msg);
}
else
{
if (dict["data"].Count == 1)
{
var item = dict["data"][0];
result = new ConfigItem();
result.Key = item["key"].Value;
result.Value = item["value"].Value;
result.Type = (ConfigType)Enum.Parse(typeof(ConfigType), item["type"].Value, true);
result.ExpireTime = Helper.ConvertTime(item["endtime"].Value);
result.MD5 = item["md5"].Value;
result.ID = string.Format("{0}:{1}", (int)result.Type, result.Key);
if (result.Status == ItemStatus.KeyNotFound)
{
e = new KeyNotFoundException(key);
}
}
else
{
e = new KeyNotFoundException(key);
}
}
}
else
{
e = new ActiveConfigException("Parsing json failed");
}
}
catch (Exception err)
{
e = new ActiveConfigException("Parsing json failed", err);
}
}
callback(result, e);
});
}
public void SaveFeaturesTest()
{
FeatureSheet target = new FeatureSheet(); // TODO: Initialize to an appropriate value
TreeView tv = null; // TODO: Initialize to an appropriate value
// TODO: SaveFeatures depends on settings in Param class being loaded!
CommonTestMethod.DisableDebugAsserts();
try
{
target.SaveFeatures(tv);
Assert.Fail("SaveFeatures returned when Param not loaded!");
}
catch (Exception e)
{
KeyNotFoundException expectedException = new KeyNotFoundException();
Assert.AreEqual(expectedException.GetType(), e.GetType());
}
finally
{
CommonTestMethod.EnableDebugAsserts();
}
}
public static InternalError CreateNotFound( KeyNotFoundException notFoundException)
{
return new InternalError(ErrorCodes.ErrorCodeEntryDoesNotExist, notFoundException.Message);
}