| Method;text;Specification;Label | |
| Add(T);Consider the method Add(object) of the class List. Precondition(s): The method expects a non-null object. Method: It then adds the object to the end of the List. Postcondition(s): The method expects that the last item of the List is the object.;"object != null; list.Add(object); list[list.Count - 1]==object;";1 | |
| AddRange(IEnumerable<T>);Consider the method AddRange(collection) of the class List. Precondition(s): The method expects a non-null collection. Method: It then adds the elements of the specified collection to the end of the List. Postcondition(s): The method expects that all the items of the collection are in the list.;"collection != null; list.AddRange(collection); foreach (T element in collection) { list.Contains(element)==TRUE }";1 | |
| AsReadOnly();Consider the method AsReadOnly() of the class List. Precondition(s): The method expects a non-null List. Method: It then returns a read-only wrapper for the current List.;"list != null; list.AsReadOnly();";1 | |
| BinarySearch(Int32, Int32, T, IComparer<T>);Consider the method BinarySearch(index, count, element, comparer) of the class List. Precondition(s): The method expects a non-null comparer and element. The method expects the index to be higher or equal to 0 and lower than the size of the List. The method expects the count to be lower or equal to the size of the List minus the index. Method: Then the method searches then between a range of int and int2 in the list and returns the zero-based index of the comparer if it is found. It then returns the index of the comparer if it is found within the range of the List that starts at the index and stops till the count is reached.;"comparer != null; element != null; 0 <= index <list.Count; count <= list.Count - index; list.BinarySearch(index, count, element, comparer);";1 | |
| BinarySearch(T);Consider the method BinarySearch(element) of the class List. Precondition(s): The method expects a non-null element. Method: It then searches the entire binary sorted list for the element and returns the index of the element if it is found. ;"element != null; list.BinarySearch(element);";1 | |
| BinarySearch(T, IComparer<T>);Consider the method BinarySearch(element, comparer) of the class List. Precondition(s): The method expects a non-null element. The method expects a non-null comparer. Then the method binary searches the entire list and returns the index of the comparer if it is found.;"comparer != null; element != null; elements.BinarySearch(element, comparer)";1 | |
| Clear();Consider the method Clear() of the class List. Method: It then removes all the items of the List. Postcondition(s): The method expects then that the size of the List is zero.;"list.Clear(); list.Count == 0;";1 | |
| Contains(T);Consider the method Contains(element) of the class List. Precondition(s): The method expects a non-null element. Method: It then returns a boolean result whether the element is in the List.;"element != null; if list.Contains(element): return TRUE; else return FALSE; ";1 | |
| ConvertAll<TOutput>(Converter<T,TOutput>);Consider the method ConvertAll(Converter(List)) of the class List. Precondition(s): The method expects a non-null List. The method expects a non-null Converter. Method: Then it converts the elements in the current List to the type of the converter and returns a list containing the converted elements. ;"converter != null; list != null; list.ConvertAll(converter); ";1 | |
| CopyTo(Int32, T[], Int32, Int32);Consider the method CopyTo(index,array,arrayIndex,count) from the class List. Precondition(s): The method expects a non-null List. The method expects a non-null array. The method expects the arrayIndex to be higher or equal to 0. Method: It then copies the elements of the List starting from the arrayIndex into the array.;"list != null; array != null; arrayIndex >=0; list.CopyTo(index, array, arrayIndex, count);";1 | |
| CopyTo(T[]);Consider the method CopyTo(array) from the class List. Precondition(s): The method expects a non-null List The method expects a non-null array. Method: It then copies the elements of the List into the array. ;"list != null; array != null; list.CopyTo(array);";1 | |
| CopyTo(T[], Int32);Consider the method CopyTo(array,arrayIndex) from the class List. Precondition(s): The method expects a non-null List. The method expects a non-null array. The method expects the arrayIndex to be higher or equal to 0. Method: It then copies the elements of the List starting from the arrayIndex into the array.;"list != null; array != null; arrayIndex >=0; list.CopyTo(array, arrayIndex);";1 | |
| EnsureCapacity(Int32);Consider the method EnsureCapacity(capacity) from the class List. Precondition(s): The method expects the capacity to be 0 or higher. The method expects a non-null List. Method: It then changes the size of the list to the maximum of the size of the List and the number capacity. Postcondition(s): The size of the list is higher or equal to the capacity.;"capacity >= 0; list != null; list.Capacity = Math.Max(list.Capacity, capacity); list.Capacity >= capacity;";1 | |
| Equals(Object);Consider the method Equals(object) of the class List. Precondition(s): The method expects a non-null object. The method expects a non-null List. Method: It then returns a boolean result whether the object Collection equals the List Collection. ;"object != null; list != null; if list.Equals(object): return TRUE; else return FALSE;";1 | |
| Exists(Predicate<T>);Consider the method Exists(predicate) of the class List. Precondition(s): The method expects a non-null List The method expects a non-null predicate. Method: It then returns a boolean result whether the predicate exists in the List. ;"list != null; predicate = null; if list.Exists(predicate): return TRUE; else return FALSE;";1 | |
| Find(Predicate<T>);Consider the method Find(predicate) of the class List. Precondition(s): The method expects a non-null List The method expects a non-null predicate. Method: It then checks if the List contains the predicate and, if so, return the first occurence of the predicate within the List. ;"list != null; predicate != null; if list.Contains(predicate): list.Find(predicate);";1 | |
| FindAll(Predicate<T>);Consider the method FindAll(predicate) of the class List. Precondition(s): The method expects a non-null List The method expects a non-null predicate. Method: It then return a list of all the occurences of the predicate in the List. ;"list != null; predicate != null; list.FindAll(predicate);";1 | |
| FindIndex(Int32, Int32, Predicate<T>);Consider the method FindIndex(index, count, predicate) of the class List. Precondition(s): The method expects a non-null List The method expects a non-null predicate. The method expects the index to be higher or equal to 0 and lower than the size of the List. The method expects the count to be lower or equal to the size of the List minus the index. Method: It then returns the index of the first occurence of the predicate within the range of the List that starts at the index and stops till the count is reached. ;"list != null; predicate != null; 0 <= index < list.Count; count <= list.Count - index; list.FindIndex(index, count, predicate);";1 | |
| FindIndex(Int32, Predicate<T>);Consider the method FindIndex(index, predicate) of the class List. Precondition(s): The method expects a non-null List The method expects a non-null predicate. The method expects the index to be higher or equal to 0 and lower than the size of the List. Method: It then returns the index of the first occurence of the predicate in the List starting from the index.;"list != null; predicate != null; 0 <= index < list.Count; list.FindIndex(index, predicate);";1 | |
| FindIndex(Predicate<T>);Consider the method FindIndex(predicate) of the class List. Precondition(s): The method expects a non-null List. The method expects a non-null predicate. Method: It then returns the index of the first occurence of the predicate in the List.;"list != null; predicate != null; list.FindIndex(predicate);";1 | |
| FindLast(Predicate<T>);Consider the method FindLast(predicate) of the class List. Precondition(s): The method expects a non-null List. The method expexts a non-null predicate. Method: It then returns the index of the last occurence of the predicate in the List.;"list != null; predicate != null; list.FindIndex(predicate);";1 | |
| FindLastIndex(Int32, Int32, Predicate<T>);Consider the method FindLastIndex(index, count, predicate) of the class List. Precondition(s): The method expects a non-null List The method expects a non-null predicate. The method expects the index to be higher or equal to 0 and lower than the size of the List. The method expects the count to be lower or equal to the size of the List minus the index. Method: It then returns the index of the last occurence of the predicate within the range of the List that starts at the index and stops till the count is reached.;"list != null; predicate != null; 0 <= index < list.Count; count <= list.Count - index; list.FindLastIndex(index, count, predicate);";1 | |
| FindLastIndex(Int32, Predicate<T>);Consider the method FindLastIndex(index, predicate) of the class List. Precondition(s): The method expects a non-null List. The method expects a non-null predicate. The method expects the index to be higher or equal to 0 and lower than the size of the List. Method: It then returns the index of the last occurence of the predicate in the List starting from the index.;"list != null; predicate != null; 0 <= index < list.Count; list.FindLastIndex(index, predicate);";1 | |
| FindLastIndex(Predicate<T>);Consider the method FindLastIndex(predicate) of the class List. Precondition(s): The method expects a non-null List The method expexts a non-null predicate. Method: It then returns the index of the last occurence of the predicate in the List.;"list != null; predicate != null; list.FindLastIndex(predicate);";1 | |
| GetHashCode();Consider the method GetHashCode(element) of the class List. Precondition(s): The method expects a non-null List Method: It then returns a hash code for the List.;"list != null; list.GetHashCode();";1 | |
| GetRange(Int32, Int32);Consider the method GetRange(index,count) of the class List. Precondition(s): The method expects a non-null List. The method expects the index to be higher or equal to 0 and lower than the size of the List. The method expects the count to be lower or equal to the size of the List minus the index. Method: It then returns a copy of the list, rangeList, that begins at the specified index and continues for the specified count of times. Postcondition(s): The method expects that the size of rangeList is the given count. The method expects that the rangeList is a sub list of List, starting at the index and ending at the index plus count. ;"list != null; 0 <= index < list.Count; count <= list.Count - index; rangeList = list.GetRange(index, count); rangeList.Count == count; rangeList == list[index:index+count]";1 | |
| GetType();Consider the method GetType() of the class List. Precondition(s): The method expects a non-null List. Method: It then returns the Type of the current List. ;"list != null; list.GetType();";1 | |
| IndexOf(T);Consider the method IndexOf(element) of the class List. Precondition(s): The method expects a non-null List The method expexts a non-null element. Method: It then returns the index of the first occurence of the element in the List.;"list != null; element != null; list.IndexOf(element);";1 | |
| IndexOf(T, Int32);Consider the method Index(element, index) of the class List. Precondition(s): The method expects a non-null List. The method expects a non-null element. The method expects the index to be higher or equal to 0 and lower than the size of the List. Method: It then returns the index of the first occurrence within the range of elements in the List that extends from the specified index to the last element.;"list != null; element != null; 0 <= index < list.Count; list.IndexOf(element, index);";1 | |
| IndexOf(T, Int32, Int32);Consider the method IndexOf(element, index, count) of the class List. Precondition(s): The method expects a non-null List The method expects a non-null element. The method expects the index to be higher or equal to 0 and lower than the size of the List. The method expects the count to be lower or equal to the size of the List minus the index. Method: It then returns the index of the first occurence of the element within the range of the List that starts at the index and stops till the count is reached.;"list != null; predicate != null; 0 <= index < list.Count; count <= list.Count - index; list.IndexOf(element, index, count);";1 | |
| Capacity();Consider the method Capacity() of the class List. Method: It then gets the total number of elements the List can hold.;"list.Capacity();";1 | |
| Capacity(Int32);Consider the method Capacity(int) of the class List. Method: It then sets the total number of elements the List can hold by int.;"list.Capacity(int);";1 | |
| Count();Consider the method Count() of the class List. Method: It then gets the number of elements contained in the List.;"list.Count();";1 | |
| Item[Int32];Consider the method Item[index] of the class List. Precondition(s): The method expects a non-null List. The method expects the index to be higher or equal to 0 and lower than the size of the List. Method: It then gets the element at the specified index.;"list != null; 0 <= index < list.Count; list[index];";1 | |
| Remove(T);Consider the method Remove(element) of the class List. Precondition(s): The method expects a non-null List. The method expects a non-null element. Method: It then removes the first occurence of the element in the List.;"list != null; element != null; list.Remove(element);";1 | |
| RemoveAll(Predicate<T>);Consider the method RemoveAll(predicate) of the class List. Precondition(s): The method expects a non-null List. The method expects a non-null predicate. Method: It then removes all occurences that match the conditions defined by the specified predicate in the List. Postcondition(s): The method expects that the List does not contain an match defined by the specified predicate.;"list != null; predicate != null; list.RemoveAll(predicate); list.Contains(predicate)==FALSE;";1 | |
| RemoveAt(Int32);Consider the method Remove(index) of the class List. Precondition(s): The method expects a non-null List. The method expects the index to be higher or equal to 0 and lower than the size of the List. Method: It then removes an element at the specified index in the List.;"list != null; 0 <= index < list.Count; list.RemoveAt(index);";1 | |
| RemoveRange(Int32, Int32);Consider the method RemoveRange(index,count) of the class List. Precondition(s): The method expects a non-null List. The method expects the index to be higher or equal to 0 and lower than the size of the List. The method expects the count to be lower or equal to the size of the List minus the index. Method: It then removes a part of the List that begins at the specified index and continues for the specified count of times.;"list != null; 0 <= index < list.Count; count <= list.Count - index; list.RemoveRange(index, count);";1 | |
| Reverse();Consider the method Reverse() of the class List. Precondition(s): The method expects a non-null List. Method: It then reverses the order of the elements in the entire List.;"list != null; list.Reverse(); ";1 | |
| Reverse(Int32, Int32);Consider the method Reverse(index,count) of the class List. Precondition(s): The method expects a non-null List. The method expects the index to be higher or equal to 0 and lower than the size of the List. The method expects the count to be lower or equal to the size of the List minus the index. Method: It then reverses the order of the elements of the List in the specified range starting from index and continues for a specified count of times. ;"list != null; 0 <= index < list.Count; count <= list.Count - index; list.Reverse(index, count);";1 | |
| Slice(Int32, Int32);Consider the method Slice(index,count) of the class List. Precondition(s): The method expects a non-null List. The method expects the index to be higher or equal to 0 and lower than the size of the List. The method expects the count to be lower or equal to the size of the List minus the index. Method: It then creates a copy of the elements of the List in the specified range starting from index and continues for a specified count of times.;"list != null; 0 <= index < list.Count; count <= list.Count - index; list.Slice(index, count);";1 | |
| Sort();Consider the method Sort() of the class List. Precondition(s): The method expects a non-null List. Method: It then sorts the elements in the entire List. ;"list != null; list.Sort();";1 | |
| Sort(Comparison<T>);Consider the method Sort(Comparison) of the class List. Precondition(s): The method expects a non-null List. The method expexts a non-null Comparison. Method: It then sorts the elements in the entire List using the specified Comparison.;"list != null; comparison != null; list.Sort(comparison);";1 | |
| Sort(IComparer<T>);Consider the method Sort(comparer) of the class List. Precondition(s): The method expects a non-null List. The method expexts a non-null comparer. Method: It then sorts the elements in the entire List using the specified comparer.;"list != null; comparer != null; list.Sort(comparer);";1 | |
| Sort(Int32, Int32, IComparer<T>);Consider the method Sort(index,count,comparer) of the class List. Precondition(s): The method expects a non-null List. The method expexts a non-null comparer. The method expects the index to be higher or equal to 0 and lower than the size of the List. The method expects the count to be lower or equal to the size of the List minus the index. Method: It then sorts the elements in the entire List using the specified comparer.;"list != null; comparer != null; 0 <= index < list.Count; count <= list.Count - index; list.Sort(index, count,comparer);";1 | |
| ToArray();Consider the method ToArray() of the class List. Preconditions: The method expects a non-null List. Method: It then copies the elements of the List to a new array.;"list != null; list.ToArray(); ";1 | |
| ToString();Consider the method ToString() of the class List. Preconditions: The method expects a non-null List. Method: It then returns a string that represents the current List.;"list != null; list.ToString();";1 | |
| TrimExcess();Consider the method TrimExcess() from the class List. Precondition(s): The method expects a non-null List. Method: It then changes the size of the list to the actual number of elements of the List, if that number is less than a threshold value. Postcondition(s): The method expects there are no null places in the List. ;"list != null; list.TrimExcess(); foreach (var element in list) { element != null; } ";1 | |
| TrueForAll(Predicate<T>);Determines whether every element in the List<T> matches the conditions defined by the specified predicate. Consider the Method TrueForAll(predicate). Precondition(s): The method expects a non-null List. The method expects a non-null predicate. Method: It then return a boolean whether every element in the List matches the conditions defined by the specified predicate. ;"list != null; predicate != null; if list.TrueForAll(predicate) { return TRUE; } else FALSE;";1 | |
| List<T>(Int32);Consider the method List(capacity) of the class List. Method: Initializes a new instance of the List class that is empty and has the specified initial capacity.;"list = List(capacity);";1 | |