//~ Methods //////////////////////////////////////////////////////////////// public override ICollection GetKeys(String prefix, int type) { lock (this) { IList result = new LinkedList(); foreach(String key in Map.Keys){ if ((prefix == null) || key.StartsWith(prefix)) { if (type == 0) { result.Add(key); } else { ValueEntry v = (ValueEntry) Map[key]; if (v.type == type) { result.Add(key); } } } } Collections.Sort(result); return result; } }
public void RuleForSelectiveRollbackOnCheckedWithClass() { IList list = new LinkedList(); list.Add( new RollbackRuleAttribute(typeof(TransactionSystemException))); RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute( TransactionPropagation.Required, list ); ruleForSelectionRollbackOnChecked( rta ); }
/// <summary> /// Initializes a new instance of the <see cref="CachedSession"/> class. /// </summary> /// <param name="targetSession">The target session.</param> /// <param name="sessionList">The session list.</param> /// <param name="ccf">The CachingConnectionFactory.</param> public CachedSession(ISession targetSession, LinkedList sessionList, CachingConnectionFactory ccf) { target = targetSession; this.sessionList = sessionList; sessionCacheSize = ccf.SessionCacheSize; shouldCacheProducers = ccf.CacheProducers; shouldCacheConsumers = ccf.CacheConsumers; this.ccf = ccf; }
public void RuleForCommitOnSubclassOfChecked() { IList list = new LinkedList(); list.Add( new RollbackRuleAttribute("System.Data.DataException")); list.Add( new NoRollbackRuleAttribute("Spring.Transaction.TransactionSystemException")); RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute( TransactionPropagation.Required, list ); Assert.IsTrue( rta.RollbackOn(new SystemException())); Assert.IsFalse( rta.RollbackOn(new TransactionSystemException())); }
public void AddMultipleObjects() { LinkedList ll = new LinkedList(); ll.Add("item1"); ll.Add("item2"); ll.Add("item3"); Assert.IsTrue(ll.Count == 3, "Expected 3 items not " + ll.Count); Assert.IsTrue(ll[0].Equals("item1"), "Expected first element to be \"item1\" not " + ll[0]); Assert.IsTrue(ll[1].Equals("item2"), "Expected second element to be \"item2\" not " + ll[1]); }
public void Insert() { LinkedList ll = new LinkedList(); ll.Add("item1"); ll.Add("item2"); ll.Insert(1, "item1andahalf"); Assert.IsTrue(ll.Count == 3, "Expected 3 items not " + ll.Count); Assert.IsTrue(ll[0].Equals("item1"), "Expected first element to be \"item1\" not " + ll[0]); Assert.IsTrue(ll[1].Equals("item1andahalf"), "Expected second element to be \"item1andahalf\" not " + ll[1]); Assert.IsTrue(ll[2].Equals("item2"), "Expected third element to be \"item2\" not " + ll[0]); }
public void RemoveAt() { LinkedList ll = new LinkedList(); ll.Add("item1"); ll.Add("item2"); ll.Add("item3"); ll.RemoveAt(1); Assert.IsTrue(ll.Count == 2, "Expected 2 items not " + ll.Count); Assert.IsTrue(ll[0].Equals("item1"), "Expected first element to be \"item1\" not " + ll[0]); Assert.IsTrue(ll[1].Equals("item3"), "Expected second element to be \"item3\" not " + ll[1]); }
public void RollbackNever() { IList list = new LinkedList(); list.Add( new NoRollbackRuleAttribute("System.Exception")); RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute( TransactionPropagation.Required, list ); Assert.IsFalse(rta.RollbackOn(new SystemException())); Assert.IsFalse(rta.RollbackOn(new DataException())); Assert.IsFalse(rta.RollbackOn(new ApplicationException())); Assert.IsFalse(rta.RollbackOn(new TransactionSystemException())); }
public void RuleForRollbackOnApplicationException() { IList list = new LinkedList(); list.Add(new RollbackRuleAttribute("Spring.Transaction.TransactionSystemException")); RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute( TransactionPropagation.Required, list ); Assert.IsTrue( rta.RollbackOn(new SystemException())); //mlp 3/17 changed rollback to rollback on all exceptions. Assert.IsTrue( rta.RollbackOn(new ApplicationException())); Assert.IsTrue(( rta.RollbackOn( new TransactionSystemException()))); }
public void RemoveObject() { string item1 = "item1"; string item2 = "item2"; string item3 = "item3"; LinkedList ll = new LinkedList(); ll.Add(item1); ll.Add(item2); ll.Add(item3); ll.Remove(item2); Assert.IsTrue(ll.Count == 2, "Expected 2 items not " + ll.Count); Assert.IsTrue(ll[0].Equals("item1"), "Expected first element to be \"item1\" not " + ll[0]); Assert.IsTrue(ll[1].Equals("item3"), "Expected second element to be \"item3\" not " + ll[1]); }
public void RemoveAtOnEmptyLinkedList() { LinkedList ll = new LinkedList(); Assert.Throws<ArgumentOutOfRangeException>(() => ll.RemoveAt(0)); }
/// <summary> /// Wraps the given Session so that it delegates every method call to the target session but /// adapts close calls. This is useful for allowing application code to /// handle a special framework Session just like an ordinary Session. /// </summary> /// <param name="targetSession">The original Session to wrap.</param> /// <param name="sessionList">The List of cached Sessions that the given Session belongs to.</param> /// <returns>The wrapped Session</returns> protected virtual ISession GetCachedSessionWrapper(ISession targetSession, LinkedList sessionList) { return new CachedSession(targetSession, sessionList, this); }
public void ConstructorWithIList() { ArrayList al = new ArrayList(); al.Add("al1"); al.Add("al2"); al.Add("al3"); LinkedList ll = new LinkedList(al); Assert.IsTrue(ll.Count == 3, "Expected 3 items not " + ll.Count); Assert.IsTrue(ll[0].Equals("al1"), "Expected first element to be \"al1\" not " + ll[0]); Assert.IsTrue(ll[1].Equals("al2"), "Expected second element to be \"al2\" not " + ll[1]); }
/// <summary> /// Obtaining a cached Session. /// </summary> /// <param name="con">The connection to operate on.</param> /// <param name="mode">The session ack mode.</param> /// <returns>The Session to use /// </returns> public override ISession GetSession(IConnection con, SessionMode mode) { LinkedList sessionList; lock (cachedSessions) { sessionList = (LinkedList) cachedSessions[mode]; if (sessionList == null) { sessionList = new LinkedList(); cachedSessions.Add(mode, sessionList); } } ISession session = null; lock (sessionList) { if (sessionList.Count > 0) { session = (ISession) sessionList[0]; sessionList.RemoveAt(0); } } if (session != null) { if (LOG.IsDebugEnabled) { LOG.Debug("Found cached Session for mode " + mode + ": " + (session is IDecoratorSession ? ((IDecoratorSession) session).TargetSession : session)); } } else { ISession targetSession = CreateSession(con, mode); if (LOG.IsDebugEnabled) { LOG.Debug("Creating cached Session for mode " + mode + ": " + targetSession); } session = GetCachedSessionWrapper(targetSession, sessionList); } return session; }
public void CopyToWithNegativeIndex() { LinkedList ll = new LinkedList(); ll.Add("item1"); string[] strings = new string[1]; Assert.Throws<ArgumentOutOfRangeException>(() => ll.CopyTo(strings, -1)); }
public void CopyToWithNullArray() { LinkedList ll = new LinkedList(); ll.Add("item1"); Assert.Throws<ArgumentNullException>(() => ll.CopyTo(null, 0)); }
public void CopyToWithNonZeroIndex() { LinkedList ll = new LinkedList(); ll.Add("item1"); ll.Add("item2"); ll.Add("item3"); string[] strings = new string[5]; strings[0] = "string1"; strings[1] = "string2"; ll.CopyTo(strings, 2); Assert.IsTrue(strings[0].Equals("string1"), "Expected first element to be \"string1\" not " + strings[0]); Assert.IsTrue(strings[1].Equals("string2"), "Expected second element to be \"string2\" not " + strings[1]); Assert.IsTrue(strings[2].Equals("item1"), "Expected third element to be \"item1\" not " + strings[2]); Assert.IsTrue(strings[3].Equals("item2"), "Expected fourth element to be \"item2\" not " + strings[3]); Assert.IsTrue(strings[4].Equals("item3"), "Expected fifth element to be \"item3\" not " + strings[4]); }
public void CopyToWithZeroIndex() { LinkedList ll = new LinkedList(); ll.Add("item1"); ll.Add("item2"); ll.Add("item3"); string[] strings = new string[3]; ll.CopyTo(strings, 0); Assert.IsTrue(strings[0].Equals("item1"), "Expected first element to be \"item1\" not " + strings[0]); Assert.IsTrue(strings[1].Equals("item2"), "Expected second element to be \"item2\" not " + strings[1]); Assert.IsTrue(strings[2].Equals("item3"), "Expected third element to be \"item3\" not " + strings[2]); }
public void IndexOfObject() { string item1 = "item1"; string item2 = "item2"; string item3 = "item3"; LinkedList ll = new LinkedList(); ll.Add(item1); ll.Add(item2); ll.Add(item3); int index = ll.IndexOf(item2); Assert.IsTrue(index == 1, "Expected index of 1 not " + index); }
public LinkedListEnumerator(LinkedList ll) { this._ll = ll; this._modId = ll._modId; this._current = _ll._rootNode; }
/// <summary> /// Return the transaction attribute, given this set of attributes /// attached to a method or class. Return null if it's not transactional. /// </summary> /// <remarks> /// Protected rather than private as subclasses may want to customize /// how this is done: for example, returning a /// <see cref="Spring.Transaction.Interceptor.ITransactionAttribute"/> /// affected by the values of other attributes. /// This implementation takes into account /// <see cref="Spring.Transaction.Interceptor.RollbackRuleAttribute"/>s, if /// the TransactionAttribute is a RuleBasedTransactionAttribute. /// </remarks> /// <param name="attributes"> /// Attributes attached to a method or class. May be null, in which case a null /// <see cref="Spring.Transaction.Interceptor.ITransactionAttribute"/> will be returned. /// </param> /// <returns> /// The <see cref="ITransactionAttribute"/> configured transaction attribute, or null /// if none was found. /// </returns> protected virtual ITransactionAttribute FindTransactionAttribute(Attribute[] attributes) { if (null == attributes) { return null; } ITransactionAttribute transactionAttribute = null; foreach (Attribute currentAttribute in attributes) { transactionAttribute = currentAttribute as ITransactionAttribute; if (null != transactionAttribute) { break; } } RuleBasedTransactionAttribute ruleBasedTransactionAttribute = transactionAttribute as RuleBasedTransactionAttribute; if (null != ruleBasedTransactionAttribute) { IList rollbackRules = new LinkedList(); foreach (Attribute currentAttribute in attributes) { RollbackRuleAttribute rollbackRuleAttribute = currentAttribute as RollbackRuleAttribute; if (null != rollbackRuleAttribute) { rollbackRules.Add(rollbackRuleAttribute); } } ruleBasedTransactionAttribute.RollbackRules = rollbackRules; return ruleBasedTransactionAttribute; } return transactionAttribute; }
public void Enumerator() { LinkedList ll = new LinkedList(); ll.Add("item1"); ll.Add("item2"); ll.Add("item3"); IEnumerator ienum = ll.GetEnumerator(); Assert.IsTrue(ienum.MoveNext()); Assert.IsTrue(ienum.Current.Equals("item1"), "Expected first element to be \"item1\" not " + ienum.Current); Assert.IsTrue(ienum.MoveNext()); Assert.IsTrue(ienum.Current.Equals("item2"), "Expected second element to be \"item2\" not " + ienum.Current); }
public void CopyToWithIndexGreaterThanArrayLength() { LinkedList ll = new LinkedList(); ll.Add("item1"); string[] strings = new string[1]; Assert.Throws<ArgumentOutOfRangeException>(() => ll.CopyTo(strings, 2)); }
public void EnumeratorModification() { LinkedList ll = new LinkedList(); ll.Add("item1"); ll.Add("item2"); ll.Add("item3"); IEnumerator ienum = ll.GetEnumerator(); Assert.IsTrue(ienum.MoveNext()); ll.RemoveAt(0); Assert.Throws<InvalidOperationException>(() => ienum.MoveNext()); }
/// <summary> /// Adds the session and connection to the list of resources managed by this holder. /// </summary> /// <param name="session">The session.</param> /// <param name="connection">The connection.</param> public void AddSession(ISession session, IConnection connection) { AssertUtils.IsTrue(!frozen, "Cannot add ISession because MessageResourceHolder is frozen"); AssertUtils.ArgumentNotNull(session, "ISession must not be null"); if (!sessions.Contains(session)) { sessions.Add(session); if (connection != null) { IList sessionsList = (IList)sessionsPerIConnection[connection]; if (sessionsList == null) { sessionsList = new LinkedList(); sessionsPerIConnection[connection] = sessionsList; } sessionsList.Add(session); } } }
public void CopyToWithInsufficientSizeArray() { LinkedList ll = new LinkedList(); ll.Add("item1"); ll.Add("item2"); string[] strings = new string[2]; Assert.Throws<ArgumentException>(() => ll.CopyTo(strings, 1)); }
/// <summary> /// Create an array of arguments to invoke a constructor or static factory method, /// given the resolved constructor arguments values. /// </summary> /// <remarks>When return value is null the out parameter UnsatisfiedDependencyExceptionData will contain /// information for use in throwing a UnsatisfiedDependencyException by the caller. This avoids using /// exceptions for flow control as in the original implementation.</remarks> private ArgumentsHolder CreateArgumentArray(string objectName, RootObjectDefinition rod, ConstructorArgumentValues resolvedValues, ObjectWrapper wrapper, Type[] paramTypes, MethodBase methodOrCtorInfo, bool autowiring, out UnsatisfiedDependencyExceptionData unsatisfiedDependencyExceptionData) { string methodType = (methodOrCtorInfo is ConstructorInfo) ? "constructor" : "factory method"; unsatisfiedDependencyExceptionData = null; ArgumentsHolder args = new ArgumentsHolder(paramTypes.Length); ISet usedValueHolders = new HybridSet(); IList autowiredObjectNames = new LinkedList(); bool resolveNecessary = false; ParameterInfo[] argTypes = methodOrCtorInfo.GetParameters(); for (int paramIndex = 0; paramIndex < paramTypes.Length; paramIndex++) { Type paramType = paramTypes[paramIndex]; string parameterName = argTypes[paramIndex].Name; // If we couldn't find a direct match and are not supposed to autowire, // let's try the next generic, untyped argument value as fallback: // it could match after type conversion (for example, String -> int). ConstructorArgumentValues.ValueHolder valueHolder = null; if (resolvedValues.GetNamedArgumentValue(parameterName) != null) { valueHolder = resolvedValues.GetArgumentValue(parameterName, paramType, usedValueHolders); } else { valueHolder = resolvedValues.GetArgumentValue(paramIndex, paramType, usedValueHolders); } if (valueHolder == null && !autowiring) { valueHolder = resolvedValues.GetGenericArgumentValue(null, usedValueHolders); } if (valueHolder != null) { // We found a potential match - let's give it a try. // Do not consider the same value definition multiple times! usedValueHolders.Add(valueHolder); args.rawArguments[paramIndex] = valueHolder.Value; try { object originalValue = valueHolder.Value; object convertedValue = TypeConversionUtils.ConvertValueIfNecessary(paramType, originalValue, null); args.arguments[paramIndex] = convertedValue; //? args.preparedArguments[paramIndex] = convertedValue; } catch (TypeMismatchException ex) { //To avoid using exceptions for flow control, this is not a cost in Java as stack trace is lazily created. string errorMessage = String.Format(CultureInfo.InvariantCulture, "Could not convert {0} argument value [{1}] to required type [{2}] : {3}", methodType, valueHolder.Value, paramType, ex.Message); unsatisfiedDependencyExceptionData = new UnsatisfiedDependencyExceptionData(paramIndex, paramType, errorMessage); return null; } } else { // No explicit match found: we're either supposed to autowire or // have to fail creating an argument array for the given constructor. if (!autowiring) { string errorMessage = String.Format(CultureInfo.InvariantCulture, "Ambiguous {0} argument types - " + "Did you specify the correct object references as {0} arguments?", methodType); unsatisfiedDependencyExceptionData = new UnsatisfiedDependencyExceptionData(paramIndex, paramType, errorMessage); return null; } try { MethodParameter param = MethodParameter.ForMethodOrConstructor(methodOrCtorInfo, paramIndex); object autowiredArgument = ResolveAutoWiredArgument(param, objectName, autowiredObjectNames); args.rawArguments[paramIndex] = autowiredArgument; args.arguments[paramIndex] = autowiredArgument; args.preparedArguments[paramIndex] = new AutowiredArgumentMarker(); resolveNecessary = true; } catch (ObjectsException ex) { unsatisfiedDependencyExceptionData = new UnsatisfiedDependencyExceptionData(paramIndex, paramType, ex.Message); return null; } } } foreach (string autowiredObjectName in autowiredObjectNames) { if (log.IsDebugEnabled) { log.Debug("Autowiring by type from object name '" + objectName + "' via " + methodType + " to object named '" + autowiredObjectName + "'"); } } return args; }
public void Contains() { LinkedList ll = new LinkedList(); Assert.IsFalse(ll.Contains("Foo")); ll = new LinkedList(); Assert.IsFalse(ll.Contains(null)); ll.Add("Foo"); ll.Add(null); ll.Add("Bar"); Assert.IsTrue(ll.Contains(null)); Assert.IsTrue(ll.Contains("Bar")); Assert.IsTrue(ll.Contains("Foo")); ll = new LinkedList(); ll.Add("Foo"); ll.Add("Bar"); Assert.IsFalse(ll.Contains(null)); }
private AbstractObjectDefinition ParseAttributeSource(XmlElement element, ParserContext parserContext) { XmlNodeList methods = element.SelectNodes("*[local-name()='method' and namespace-uri()='" + element.NamespaceURI + "']"); ManagedDictionary transactionAttributeMap = new ManagedDictionary(); foreach (XmlElement methodElement in methods) { string name = GetAttributeValue(methodElement, "name"); TypedStringValue nameHolder = new TypedStringValue(name); RuleBasedTransactionAttribute attribute = new RuleBasedTransactionAttribute(); string propagation = GetAttributeValue(methodElement, PROPAGATION); string isolation = GetAttributeValue(methodElement, ISOLATION); string timeout = GetAttributeValue(methodElement, TIMEOUT); string readOnly = GetAttributeValue(methodElement, READ_ONLY); if (StringUtils.HasText(propagation)) { attribute.PropagationBehavior = (TransactionPropagation) Enum.Parse(typeof (TransactionPropagation), propagation, true); } if (StringUtils.HasText(isolation)) { attribute.TransactionIsolationLevel = (IsolationLevel) Enum.Parse(typeof (IsolationLevel), isolation, true); } if (StringUtils.HasText(timeout)) { try { attribute.TransactionTimeout = Int32.Parse(timeout); } catch (FormatException ex) { parserContext.ReaderContext.ReportException(methodElement,"tx advice","timeout must be an integer value: [" + timeout + "]", ex); } } if (StringUtils.HasText(readOnly)) { attribute.ReadOnly = Boolean.Parse(GetAttributeValue(methodElement, READ_ONLY)); } IList rollbackRules = new LinkedList(); if (methodElement.HasAttribute(ROLLBACK_FOR)) { string rollbackForValue = GetAttributeValue(methodElement, ROLLBACK_FOR); AddRollbackRuleAttributesTo(rollbackRules, rollbackForValue); } if (methodElement.HasAttribute(NO_ROLLBACK_FOR)) { string noRollbackForValue = GetAttributeValue(methodElement, NO_ROLLBACK_FOR); AddNoRollbackRuleAttributesTo(rollbackRules, noRollbackForValue); } attribute.RollbackRules = rollbackRules; transactionAttributeMap[nameHolder] = attribute; } ObjectDefinitionBuilder builder = parserContext .ParserHelper .CreateRootObjectDefinitionBuilder(typeof (NameMatchTransactionAttributeSource)); builder.AddPropertyValue(NAME_MAP, transactionAttributeMap); return builder.ObjectDefinition; }
public void RemoveAtOnEmptyLinkedList() { LinkedList ll = new LinkedList(); ll.RemoveAt(0); }