27 changed files with 328 additions and 3860 deletions
File diff suppressed because it is too large
Load Diff
@ -1,83 +0,0 @@
|
||||
/** |
||||
* Iterator for iterating over `AssociativeArray`'s items. |
||||
* Copyright 2020 Anton Tarasenko |
||||
*------------------------------------------------------------------------------ |
||||
* This file is part of Acedia. |
||||
* |
||||
* Acedia is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, version 3 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* Acedia is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||
*/ |
||||
class AssociativeArrayIterator extends CollectionIterator |
||||
dependson(AssociativeArray); |
||||
|
||||
var private bool hasNotFinished; |
||||
var private AssociativeArray relevantCollection; |
||||
var private AssociativeArray.Index currentIndex; |
||||
|
||||
protected function Finalizer() |
||||
{ |
||||
relevantCollection = none; |
||||
} |
||||
|
||||
public function bool Initialize(Collection relevantArray) |
||||
{ |
||||
local AssociativeArray.Index emptyIndex; |
||||
currentIndex = emptyIndex; |
||||
relevantCollection = AssociativeArray(relevantArray); |
||||
if (relevantCollection == none) { |
||||
return false; |
||||
} |
||||
hasNotFinished = (relevantCollection.GetLength() > 0); |
||||
if (GetKey() == none) { |
||||
relevantCollection.IncrementIndex(currentIndex); |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
public function Iter Next(optional bool skipNone) |
||||
{ |
||||
local int collectionLength; |
||||
if (!skipNone) |
||||
{ |
||||
hasNotFinished = relevantCollection.IncrementIndex(currentIndex); |
||||
return self; |
||||
} |
||||
collectionLength = relevantCollection.GetLength(); |
||||
while (hasNotFinished) |
||||
{ |
||||
hasNotFinished = relevantCollection.IncrementIndex(currentIndex); |
||||
if (relevantCollection.GetEntryByIndex(currentIndex).value != none) { |
||||
return self; |
||||
} |
||||
} |
||||
return self; |
||||
} |
||||
|
||||
public function AcediaObject Get() |
||||
{ |
||||
return relevantCollection.GetEntryByIndex(currentIndex).value; |
||||
} |
||||
|
||||
public function AcediaObject GetKey() |
||||
{ |
||||
return relevantCollection.GetEntryByIndex(currentIndex).key; |
||||
} |
||||
|
||||
public function bool HasFinished() |
||||
{ |
||||
return !hasNotFinished; |
||||
} |
||||
|
||||
defaultproperties |
||||
{ |
||||
} |
||||
@ -1,817 +0,0 @@
|
||||
/** |
||||
* Dynamic array object for storing arbitrary types of data. Generic |
||||
* storage is achieved by using `AcediaObject` as the stored type. Native |
||||
* variable types such as `int`, `bool`, etc. can be stored by boxing them into |
||||
* `AcediaObject`s. |
||||
* Appropriate classes and APIs for their construction are provided for |
||||
* main primitive types and can be extended to any custom `struct`. |
||||
* Copyright 2020 - 2021 Anton Tarasenko |
||||
*------------------------------------------------------------------------------ |
||||
* This file is part of Acedia. |
||||
* |
||||
* Acedia is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, version 3 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* Acedia is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||
*/ |
||||
class DynamicArray extends Collection; |
||||
|
||||
// Actual storage of all our data. |
||||
var private array<AcediaObject> storedObjects; |
||||
// `managedFlags[i] > 0` iff `contents[i]` is a managed object. |
||||
// Invariant `managedFlags.length == contents.length` should be enforced by |
||||
// all methods. |
||||
var private array<byte> managedFlags; |
||||
// Recorded `lifeVersions` of all stored objects. |
||||
// Invariant `lifeVersions.length == contents.length` should be enforced by |
||||
// all methods. |
||||
var private array<int> lifeVersions; |
||||
|
||||
// Free array data |
||||
protected function Finalizer() |
||||
{ |
||||
Empty(); |
||||
} |
||||
|
||||
// Method, used to compare array values at different indices. |
||||
// Does not check boundary conditions, so make sure passed indices are valid. |
||||
private function bool AreEqual(AcediaObject object1, AcediaObject object2) |
||||
{ |
||||
if (object1 == none && object2 == none) return true; |
||||
if (object1 == none || object2 == none) return false; |
||||
|
||||
return object1.IsEqual(object2); |
||||
} |
||||
|
||||
/** |
||||
* Returns current length of dynamic `DynamicArray`. |
||||
* Cannot fail. |
||||
* |
||||
* @return Returns length of the caller `DynamicArray`. |
||||
* Guaranteed to be non-negative. |
||||
*/ |
||||
public final function int GetLength() |
||||
{ |
||||
return storedObjects.length; |
||||
} |
||||
|
||||
/** |
||||
* Changes length of the caller `DynamicArray`. |
||||
* If `DynamicArray` size is increased as a result - added items will be |
||||
* filled with `none`s. |
||||
* If `DynamicArray` size is decreased - erased managed items will be |
||||
* automatically deallocated. |
||||
* |
||||
* @param newLength New length of an `DynamicArray`. |
||||
* If negative value is passes - method will do nothing. |
||||
* @return Reference to the caller `DynamicArray` to allow for method chaining. |
||||
*/ |
||||
public final function DynamicArray SetLength(int newLength) |
||||
{ |
||||
local int i; |
||||
if (newLength < 0) { |
||||
return self; |
||||
} |
||||
for (i = newLength; i < storedObjects.length; i += 1) { |
||||
FreeManagedItem(i); |
||||
} |
||||
storedObjects.length = newLength; |
||||
managedFlags.length = newLength; |
||||
lifeVersions.length = newLength; |
||||
return self; |
||||
} |
||||
|
||||
/** |
||||
* Deallocates an item at a given index `index`, if it's managed. |
||||
* Does not check `DynamicArray` bounds for `index`, so you must ensure that |
||||
* `index` is valid. |
||||
* |
||||
* @param index Index of the managed item to deallocate. |
||||
* @return Reference to the caller `DynamicArray` to allow for method chaining. |
||||
*/ |
||||
protected final function DynamicArray FreeManagedItem(int index) |
||||
{ |
||||
if (storedObjects[index] == none) return self; |
||||
if (!storedObjects[index].IsAllocated()) return self; |
||||
if (managedFlags[index] <= 0) return self; |
||||
if (lifeVersions[index] != storedObjects[index].GetLifeVersion()) { |
||||
return self; |
||||
} |
||||
if ( storedObjects[index] != none && managedFlags[index] > 0 |
||||
&& lifeVersions[index] == storedObjects[index].GetLifeVersion()) |
||||
{ |
||||
storedObjects[index].FreeSelf(); |
||||
storedObjects[index] = none; |
||||
} |
||||
return self; |
||||
} |
||||
|
||||
public function Empty(optional bool deallocateKeys) |
||||
{ |
||||
local int i; |
||||
local Collection subCollection; |
||||
if (deallocateKeys) |
||||
{ |
||||
for (i = 0; i < storedObjects.length; i += 1) |
||||
{ |
||||
subCollection = Collection(GetItem(i)); |
||||
if (subCollection != none) { |
||||
subCollection.Empty(true); |
||||
} |
||||
} |
||||
} |
||||
SetLength(0); |
||||
} |
||||
|
||||
/** |
||||
* Adds `amountOfNewItems` empty (`none`) items at the end of |
||||
* the `DynamicArray`. |
||||
* To insert items at an arbitrary array index, use `Insert()`. |
||||
* |
||||
* @param amountOfNewItems Amount of items to add at the end. |
||||
* If non-positive value is passed, - method does nothing. |
||||
* @return Reference to the caller `DynamicArray` to allow for method chaining. |
||||
*/ |
||||
public final function DynamicArray Add(int amountOfNewItems) |
||||
{ |
||||
if (amountOfNewItems > 0) { |
||||
SetLength(storedObjects.length + amountOfNewItems); |
||||
} |
||||
return self; |
||||
} |
||||
|
||||
/** |
||||
* Inserts `count` empty (`none`) items into the `DynamicArray` |
||||
* at specified position. |
||||
* The indices of the following items are increased by `count` in order |
||||
* to make room for the new items. |
||||
* |
||||
* To add items at the end of an `DynamicArray`, consider using `Add()`, |
||||
* which is equivalent to `array.Insert(array.GetLength(), ...)`. |
||||
* |
||||
* @param index Index, where first inserted item will be located. |
||||
* Must belong to `[0; self.GetLength()]` inclusive interval, |
||||
* otherwise method does nothing. |
||||
* @param count Amount of new items to insert. |
||||
* Must be positive, otherwise method does nothing. |
||||
* @return Reference to the caller `DynamicArray` to allow for method chaining. |
||||
*/ |
||||
public final function DynamicArray Insert(int index, int count) |
||||
{ |
||||
local int i; |
||||
local int swapIndex; |
||||
local int amountToShift; |
||||
|
||||
if (count <= 0) return self; |
||||
if (index < 0 || index > storedObjects.length) return self; |
||||
|
||||
amountToShift = storedObjects.length - index; |
||||
Add(count); |
||||
if (amountToShift == 0) { |
||||
return self; |
||||
} |
||||
for (i = 0; i < amountToShift; i += 1) |
||||
{ |
||||
swapIndex = storedObjects.length - i - 1; |
||||
Swap(swapIndex, swapIndex - count); |
||||
} |
||||
return self; |
||||
} |
||||
|
||||
/** |
||||
* Swaps two `DynamicArray` items, along with information about their |
||||
* managed status. |
||||
* |
||||
* @param index1 Index of item to swap. |
||||
* @param index2 Index of item to swap. |
||||
*/ |
||||
protected final function Swap(int index1, int index2) |
||||
{ |
||||
local AcediaObject temporaryItem; |
||||
local int temporaryNumber; |
||||
// Swap object |
||||
temporaryItem = storedObjects[index1]; |
||||
storedObjects[index1] = storedObjects[index2]; |
||||
storedObjects[index2] = temporaryItem; |
||||
// Swap life versions |
||||
temporaryNumber = lifeVersions[index1]; |
||||
lifeVersions[index1] = lifeVersions[index2]; |
||||
lifeVersions[index2] = temporaryNumber; |
||||
// Swap managed flags |
||||
temporaryNumber = managedFlags[index1]; |
||||
managedFlags[index1] = managedFlags[index2]; |
||||
managedFlags[index2] = temporaryNumber; |
||||
} |
||||
|
||||
/** |
||||
* Removes number items from the `DynamicArray`, starting at `index`. |
||||
* All items before position and from `index + count` on are not changed, |
||||
* but the item indices change, - they shift to close the gap, |
||||
* created by removed items. |
||||
* |
||||
* @param index Remove items starting from this index. |
||||
* Must belong to `[0; self.GetLength() - 1]` inclusive interval, |
||||
* otherwise method does nothing. |
||||
* @param count Removes at most this much items. |
||||
* Must be positive, otherwise method does nothing. |
||||
* Specifying more items than can be removed simply removes |
||||
* all items, starting from `index`. |
||||
* @return Reference to the caller `DynamicArray` to allow for method chaining. |
||||
*/ |
||||
public final function DynamicArray Remove(int index, int count) |
||||
{ |
||||
local int i; |
||||
if (count <= 0) return self; |
||||
if (index < 0 || index > storedObjects.length) return self; |
||||
|
||||
count = Min(count, storedObjects.length - index); |
||||
for (i = 0; i < count; i += 1) { |
||||
FreeManagedItem(index + i); |
||||
} |
||||
storedObjects.Remove(index, count); |
||||
managedFlags.Remove(index, count); |
||||
lifeVersions.Remove(index, count); |
||||
return self; |
||||
} |
||||
|
||||
/** |
||||
* Removes item at a given index, shifting all the items that come after |
||||
* one place backwards. |
||||
* |
||||
* @param index Remove items starting from this index. |
||||
* Must belong to `[0; self.GetLength() - 1]` inclusive interval, |
||||
* otherwise method does nothing. |
||||
* @return Reference to the caller `DynamicArray` to allow for method chaining. |
||||
*/ |
||||
public final function DynamicArray RemoveIndex(int index) |
||||
{ |
||||
Remove(index, 1); |
||||
return self; |
||||
} |
||||
|
||||
/** |
||||
* Checks if caller `DynamicArray`'s value at index `index` is managed. |
||||
* |
||||
* Managed values will be automatically deallocated once they are removed |
||||
* (or overwritten) from the caller `DynamicArray`. |
||||
* |
||||
* @return `true` if value, recorded in caller `DynamicArray` at index `index` |
||||
* is managed and `false` otherwise. |
||||
* If `index` is invalid (outside of `DynamicArray` bounds) |
||||
* also returns `false`. |
||||
*/ |
||||
public final function bool IsManaged(int index) |
||||
{ |
||||
if (index < 0) return false; |
||||
if (index >= storedObjects.length) return false; |
||||
if (storedObjects[index] == none) return false; |
||||
if (!storedObjects[index].IsAllocated()) return false; |
||||
if (storedObjects[index].GetLifeVersion() != lifeVersions[index]) { |
||||
return false; |
||||
} |
||||
|
||||
return (managedFlags[index] > 0); |
||||
} |
||||
|
||||
/** |
||||
* Returns item at `index` and replaces it with `none` inside `DynamicArray`. |
||||
* If index is invalid, returns `none`. |
||||
* |
||||
* If returned value was managed, it won't be deallocated |
||||
* and will stop being managed. |
||||
* |
||||
* @param index Index of an item that `DynamicArray` has to return. |
||||
* @return Either value at `index` in the caller `DynamicArray` or `none` if |
||||
* passed `index` is invalid. |
||||
*/ |
||||
public final function AcediaObject TakeItem(int index) |
||||
{ |
||||
local AcediaObject result; |
||||
if (index < 0) return none; |
||||
if (index >= storedObjects.length) return none; |
||||
if (storedObjects[index] == none) return none; |
||||
if (!storedObjects[index].IsAllocated()) return none; |
||||
if (storedObjects[index].GetLifeVersion() != lifeVersions[index]) { |
||||
return none; |
||||
} |
||||
|
||||
result = storedObjects[index]; |
||||
storedObjects[index] = none; |
||||
managedFlags[index] = 0; |
||||
lifeVersions[index] = 0; |
||||
return result; |
||||
} |
||||
|
||||
/** |
||||
* Returns item at `index`. If index is invalid, returns `none`. |
||||
* |
||||
* @param index Index of an item that `DynamicArray` has to return. |
||||
* @return Either value at `index` in the caller `DynamicArray` or `none` if |
||||
* passed `index` is invalid. |
||||
*/ |
||||
public final function AcediaObject GetItem(int index) |
||||
{ |
||||
if (index < 0) return none; |
||||
if (index >= storedObjects.length) return none; |
||||
if (storedObjects[index] == none) return none; |
||||
if (!storedObjects[index].IsAllocated()) return none; |
||||
if (storedObjects[index].GetLifeVersion() != lifeVersions[index]) { |
||||
return none; |
||||
} |
||||
|
||||
return storedObjects[index]; |
||||
} |
||||
|
||||
/** |
||||
* Changes `DynamicArray`'s value at `index` to `item`. |
||||
* |
||||
* @param index Index, at which to change the value. If `DynamicArray` is |
||||
* not long enough to hold it, it will be automatically expanded. |
||||
* If passed index is negative - method will do nothing. |
||||
* @param item Value to be set at a given index. |
||||
* @param managed Whether `item` should be managed by `DynamicArray`. |
||||
* By default (`false`) all items are not managed. |
||||
* @return Reference to the caller `DynamicArray` to allow for method chaining. |
||||
*/ |
||||
public final function DynamicArray SetItem( |
||||
int index, |
||||
AcediaObject item, |
||||
optional bool managed) |
||||
{ |
||||
if (index < 0) { |
||||
return self; |
||||
} |
||||
if (index >= storedObjects.length) { |
||||
SetLength(index + 1); |
||||
} |
||||
else if (item != storedObjects[index]) { |
||||
FreeManagedItem(index); |
||||
} |
||||
storedObjects[index] = item; |
||||
managedFlags[index] = 0; |
||||
if (managed) { |
||||
managedFlags[index] = 1; |
||||
} |
||||
if (item != none) { |
||||
lifeVersions[index] = item.GetLifeVersion(); |
||||
} |
||||
return self; |
||||
} |
||||
|
||||
/** |
||||
* Creates a new instance of class `valueClass` and records it's value at index |
||||
* `index` in the caller `DynamicArray`. Value is recorded as managed. |
||||
* |
||||
* @param index Index, at which to change the value. If `DynamicArray` |
||||
* is not long enough to hold it, it will be automatically expanded. |
||||
* If passed index is negative - method will do nothing. |
||||
* @param valueClass Class of object to create. Will only be created if |
||||
* passed `index` is valid. |
||||
* @return Caller `DynamicArray` to allow for method chaining. |
||||
*/ |
||||
public final function DynamicArray CreateItem( |
||||
int index, |
||||
class<AcediaObject> valueClass) |
||||
{ |
||||
if (index < 0) return self; |
||||
if (valueClass == none) return self; |
||||
|
||||
return SetItem(index, AcediaObject(_.memory.Allocate(valueClass)), true); |
||||
} |
||||
|
||||
/** |
||||
* Adds given `item` at the end of the `DynamicArray`, expanding it by |
||||
* one item. |
||||
* Cannot fail. |
||||
* |
||||
* @param item Item to be added at the end of the `DynamicArray`. |
||||
* @param managed Whether `item` should be managed by `DynamicArray`. |
||||
* By default (`false`) all items are not managed. |
||||
* @return Reference to the caller `DynamicArray` to allow for method chaining. |
||||
*/ |
||||
public final function DynamicArray AddItem( |
||||
AcediaObject item, |
||||
optional bool managed) |
||||
{ |
||||
return SetItem(storedObjects.length, item, managed); |
||||
} |
||||
|
||||
/** |
||||
* Inserts given `item` at index `index` of the `DynamicArray`, |
||||
* shifting all the items starting from `index` one position to the right. |
||||
* Cannot fail. |
||||
* |
||||
* @param index Index at which to insert new item. Must belong to |
||||
* inclusive range `[0; self.GetLength()]`, otherwise method does nothing. |
||||
* @param item Item to insert. |
||||
* @param managed Whether `item` should be managed by `DynamicArray`. |
||||
* By default (`false`) all items are not managed. |
||||
* @return Reference to the caller `DynamicArray` to allow for method chaining. |
||||
*/ |
||||
public final function DynamicArray InsertItem( |
||||
int index, |
||||
AcediaObject item, |
||||
optional bool managed) |
||||
{ |
||||
if (index < 0) return self; |
||||
if (index > storedObjects.length) return self; |
||||
|
||||
Insert(index, 1); |
||||
SetItem(index, item, managed); |
||||
return self; |
||||
} |
||||
|
||||
/** |
||||
* Returns all occurrences of `item` in the caller `DynamicArray` |
||||
* (optionally only first one). |
||||
* |
||||
* @param item Item that needs to be removed from a `DynamicArray`. |
||||
* @param onlyFirstItem Set to `true` to only remove first occurrence. |
||||
* By default `false`, which means all occurrences will be removed. |
||||
* @return Reference to the caller `DynamicArray` to allow for method chaining. |
||||
*/ |
||||
public final function DynamicArray RemoveItem( |
||||
AcediaObject item, |
||||
optional bool onlyFirstItem) |
||||
{ |
||||
local int i; |
||||
while (i < storedObjects.length) |
||||
{ |
||||
if (AreEqual(storedObjects[i], item)) |
||||
{ |
||||
Remove(i, 1); |
||||
if (onlyFirstItem) { |
||||
return self; |
||||
} |
||||
} |
||||
else { |
||||
i += 1; |
||||
} |
||||
} |
||||
return self; |
||||
} |
||||
|
||||
/** |
||||
* Finds first occurrence of `item` in caller `DynamicArray` and returns |
||||
* it's index. |
||||
* |
||||
* @param item Item to find in `DynamicArray`. |
||||
* @return Index of first occurrence of `item` in caller `DynamicArray`. |
||||
* `-1` if `item` is not found. |
||||
*/ |
||||
public final function int Find(AcediaObject item) |
||||
{ |
||||
local int i; |
||||
for (i = 0; i < storedObjects.length; i += 1) |
||||
{ |
||||
if (AreEqual(storedObjects[i], item)) { |
||||
return i; |
||||
} |
||||
} |
||||
return -1; |
||||
} |
||||
|
||||
protected function AcediaObject GetByText(BaseText key) |
||||
{ |
||||
local int index, consumed; |
||||
local Parser parser; |
||||
parser = _.text.Parse(key); |
||||
parser.MUnsignedInteger(index,,, consumed); |
||||
if (!parser.Ok()) |
||||
{ |
||||
parser.FreeSelf(); |
||||
return none; |
||||
} |
||||
parser.FreeSelf(); |
||||
return GetItem(index); |
||||
} |
||||
|
||||
/** |
||||
* Returns `bool` item at `index`. If index is invalid or |
||||
* stores a non-`bool` value, returns `defaultValue`. |
||||
* |
||||
* Referred value must be stored as `BoolBox` or `BoolRef` |
||||
* (or one of their sub-classes) for this method to work. |
||||
* |
||||
* @param index Index of a `bool` item that `DynamicArray` |
||||
* has to return. |
||||
* @param defaultValue Value to return if there is either no item recorded |
||||
* at `index` or it has a wrong type. |
||||
* @return `bool` value at `index` in the caller `DynamicArray`. |
||||
* `defaultValue` if passed `index` is invalid or non-`bool` value |
||||
* is stored there. |
||||
*/ |
||||
public final function bool GetBool(int index, optional bool defaultValue) |
||||
{ |
||||
local AcediaObject result; |
||||
local BoolBox asBox; |
||||
local BoolRef asRef; |
||||
result = GetItem(index); |
||||
if (result == none) { |
||||
return defaultValue; |
||||
} |
||||
asBox = BoolBox(result); |
||||
if (asBox != none) { |
||||
return asBox.Get(); |
||||
} |
||||
asRef = BoolRef(result); |
||||
if (asRef != none) { |
||||
return asRef.Get(); |
||||
} |
||||
return defaultValue; |
||||
} |
||||
|
||||
/** |
||||
* Changes `DynamicArray`'s value at `index` to `value` that will be recorded |
||||
* as either `BoolBox` or `BoolRef`, depending of `asRef` optional parameter. |
||||
* |
||||
* Inserted value will always be recorded as a managed value, i.e. it will be |
||||
* automatically deallocated when overwritten, removed or caller `DynamicArray` |
||||
* is deallocated. |
||||
* |
||||
* @param index Index, at which to change the value. If `DynamicArray` is |
||||
* not long enough to hold it, it will be automatically expanded. |
||||
* If passed index is negative - method will do nothing. |
||||
* @param value Value to be set at a given index. |
||||
* @param asRef Given `bool` value will be recorded as immutable `BoolBox` |
||||
* by default (`asRef == false`). Setting this parameter to `true` will |
||||
* make this method record it as a mutable `BoolRef`. |
||||
* @return Reference to the caller `DynamicArray` to allow for method chaining. |
||||
*/ |
||||
public final function DynamicArray SetBool( |
||||
int index, |
||||
bool value, |
||||
optional bool asRef) |
||||
{ |
||||
if (asRef) { |
||||
SetItem(index, _.ref.bool(value), true); |
||||
} |
||||
else { |
||||
SetItem(index, _.box.bool(value), true); |
||||
} |
||||
return self; |
||||
} |
||||
|
||||
/** |
||||
* Returns `byte` item at `index`. If index is invalid or |
||||
* stores a non-`byte` value, returns `defaultValue`. |
||||
* |
||||
* Referred value must be stored as `ByteBox` or `ByteRef` |
||||
* (or one of their sub-classes) for this method to work. |
||||
* |
||||
* @param index Index of a `byte` item that `DynamicArray` |
||||
* has to return. |
||||
* @param defaultValue Value to return if there is either no item recorded |
||||
* at `index` or it has a wrong type. |
||||
* @return `byte` value at `index` in the caller `DynamicArray`. |
||||
* `defaultValue` if passed `index` is invalid or non-`byte` value |
||||
* is stored there. |
||||
*/ |
||||
public final function byte GetByte(int index, optional byte defaultValue) |
||||
{ |
||||
local AcediaObject result; |
||||
local ByteBox asBox; |
||||
local ByteRef asRef; |
||||
result = GetItem(index); |
||||
if (result == none) { |
||||
return defaultValue; |
||||
} |
||||
asBox = ByteBox(result); |
||||
if (asBox != none) { |
||||
return asBox.Get(); |
||||
} |
||||
asRef = ByteRef(result); |
||||
if (asRef != none) { |
||||
return asRef.Get(); |
||||
} |
||||
return defaultValue; |
||||
} |
||||
|
||||
/** |
||||
* Changes `DynamicArray`'s value at `index` to `value` that will be recorded |
||||
* as either `ByteBox` or `ByteRef`, depending of `asRef` optional parameter. |
||||
* |
||||
* Inserted value will always be recorded as a managed value, i.e. it will be |
||||
* automatically deallocated when overwritten, removed or caller `DynamicArray` |
||||
* is deallocated. |
||||
* |
||||
* @param index Index, at which to change the value. If `DynamicArray` is |
||||
* not long enough to hold it, it will be automatically expanded. |
||||
* If passed index is negative - method will do nothing. |
||||
* @param value Value to be set at a given index. |
||||
* @param asRef Given `byte` value will be recorded as immutable `ByteBox` |
||||
* by default (`asRef == false`). Setting this parameter to `true` will |
||||
* make this method record it as a mutable `ByteRef`. |
||||
* @return Reference to the caller `DynamicArray` to allow for method chaining. |
||||
*/ |
||||
public final function DynamicArray SetByte( |
||||
int index, |
||||
byte value, |
||||
optional bool asRef) |
||||
{ |
||||
if (asRef) { |
||||
SetItem(index, _.ref.byte(value), true); |
||||
} |
||||
else { |
||||
SetItem(index, _.box.byte(value), true); |
||||
} |
||||
return self; |
||||
} |
||||
|
||||
/** |
||||
* Returns `int` item at `index`. If index is invalid or |
||||
* stores a non-`int` value, returns `defaultValue`. |
||||
* |
||||
* Referred value must be stored as `IntBox` or `IntRef` |
||||
* (or one of their sub-classes) for this method to work. |
||||
* |
||||
* @param index Index of a `int` item that `DynamicArray` |
||||
* has to return. |
||||
* @param defaultValue Value to return if there is either no item recorded |
||||
* at `index` or it has a wrong type. |
||||
* @return `int` value at `index` in the caller `DynamicArray`. |
||||
* `defaultValue` if passed `index` is invalid or non-`int` value |
||||
* is stored there. |
||||
*/ |
||||
public final function int GetInt(int index, optional int defaultValue) |
||||
{ |
||||
local AcediaObject result; |
||||
local IntBox asBox; |
||||
local IntRef asRef; |
||||
result = GetItem(index); |
||||
if (result == none) { |
||||
return defaultValue; |
||||
} |
||||
asBox = IntBox(result); |
||||
if (asBox != none) { |
||||
return asBox.Get(); |
||||
} |
||||
asRef = IntRef(result); |
||||
if (asRef != none) { |
||||
return asRef.Get(); |
||||
} |
||||
return defaultValue; |
||||
} |
||||
|
||||
/** |
||||
* Changes `DynamicArray`'s value at `index` to `value` that will be recorded |
||||
* as either `IntBox` or `IntRef`, depending of `asRef` optional parameter. |
||||
* |
||||
* Inserted value will always be recorded as a managed value, i.e. it will be |
||||
* automatically deallocated when overwritten, removed or caller `DynamicArray` |
||||
* is deallocated. |
||||
* |
||||
* @param index Index, at which to change the value. If `DynamicArray` is |
||||
* not long enough to hold it, it will be automatically expanded. |
||||
* If passed index is negative - method will do nothing. |
||||
* @param value Value to be set at a given index. |
||||
* @param asRef Given `int` value will be recorded as immutable `IntBox` |
||||
* by default (`asRef == false`). Setting this parameter to `true` will |
||||
* make this method record it as a mutable `IntRef`. |
||||
* @return Reference to the caller `DynamicArray` to allow for method chaining. |
||||
*/ |
||||
public final function DynamicArray SetInt( |
||||
int index, |
||||
int value, |
||||
optional bool asRef) |
||||
{ |
||||
if (asRef) { |
||||
SetItem(index, _.ref.int(value), true); |
||||
} |
||||
else { |
||||
SetItem(index, _.box.int(value), true); |
||||
} |
||||
return self; |
||||
} |
||||
|
||||
/** |
||||
* Returns `float` item at `index`. If index is invalid or |
||||
* stores a non-`int` value, returns `defaultValue`. |
||||
* |
||||
* Referred value must be stored as `FloatBox` or `FloatRef` |
||||
* (or one of their sub-classes) for this method to work. |
||||
* |
||||
* @param index Index of a `float` item that `DynamicArray` |
||||
* has to return. |
||||
* @param defaultValue Value to return if there is either no item recorded |
||||
* at `index` or it has a wrong type. |
||||
* @return `float` value at `index` in the caller `DynamicArray`. |
||||
* `defaultValue` if passed `index` is invalid or non-`float` value |
||||
* is stored there. |
||||
*/ |
||||
public final function float GetFloat(int index, optional float defaultValue) |
||||
{ |
||||
local AcediaObject result; |
||||
local FloatBox asBox; |
||||
local FloatRef asRef; |
||||
result = GetItem(index); |
||||
if (result == none) { |
||||
return defaultValue; |
||||
} |
||||
asBox = FloatBox(result); |
||||
if (asBox != none) { |
||||
return asBox.Get(); |
||||
} |
||||
asRef = FloatRef(result); |
||||
if (asRef != none) { |
||||
return asRef.Get(); |
||||
} |
||||
return defaultValue; |
||||
} |
||||
|
||||
/** |
||||
* Changes `DynamicArray`'s value at `index` to `value` that will be recorded |
||||
* as either `FloatBox` or `FloatRef`, depending of `asRef` optional parameter. |
||||
* |
||||
* Inserted value will always be recorded as a managed value, i.e. it will be |
||||
* automatically deallocated when overwritten, removed or caller `DynamicArray` |
||||
* is deallocated. |
||||
* |
||||
* @param index Index, at which to change the value. If `DynamicArray` is |
||||
* not long enough to hold it, it will be automatically expanded. |
||||
* If passed index is negative - method will do nothing. |
||||
* @param value Value to be set at a given index. |
||||
* @param asRef Given `float` value will be recorded as immutable `FloatBox` |
||||
* by default (`asRef == false`). Setting this parameter to `true` will |
||||
* make this method record it as a mutable `FloatRef`. |
||||
* @return Reference to the caller `DynamicArray` to allow for method chaining. |
||||
*/ |
||||
public final function DynamicArray SetFloat( |
||||
int index, |
||||
float value, |
||||
optional bool asRef) |
||||
{ |
||||
if (asRef) { |
||||
SetItem(index, _.ref.float(value), true); |
||||
} |
||||
else { |
||||
SetItem(index, _.box.float(value), true); |
||||
} |
||||
return self; |
||||
} |
||||
|
||||
/** |
||||
* Returns `Text` item at `index`. If index is invalid or |
||||
* stores a non-`Text` value, returns `none`. |
||||
* |
||||
* Referred value must be stored as `Text` (or one of it's sub-classes, |
||||
* such as `MutableText`) for this method to work. |
||||
* |
||||
* @param index Index of a `Text` item that `DynamicArray` has to return. |
||||
* @return `Text` value at `index` in the caller `DynamicArray`. |
||||
* `none` if passed `index` is invalid or non-`Text` value |
||||
* is stored there. |
||||
*/ |
||||
public final function Text GetText(int index) |
||||
{ |
||||
return Text(GetItem(index)); |
||||
} |
||||
|
||||
/** |
||||
* Returns `AssociativeArray` item at `index`. If index is invalid or |
||||
* stores a non-`AssociativeArray` value, returns `none`. |
||||
* |
||||
* Referred value must be stored as `AssociativeArray` |
||||
* (or one of it's sub-classes) for this method to work. |
||||
* |
||||
* @param index Index of an `AssociativeArray` item that `DynamicArray` |
||||
* has to return. |
||||
* @return `AssociativeArray` value at `index` in the caller `DynamicArray`. |
||||
* `none` if passed `index` is invalid or non-`AssociativeArray` value |
||||
* is stored there. |
||||
*/ |
||||
public final function AssociativeArray GetAssociativeArray(int index) |
||||
{ |
||||
return AssociativeArray(GetItem(index)); |
||||
} |
||||
|
||||
/** |
||||
* Returns `DynamicArray` item at `index`. If index is invalid or |
||||
* stores a non-`DynamicArray` value, returns `none`. |
||||
* |
||||
* Referred value must be stored as `Text` (or one of it's sub-classes, |
||||
* such as `MutableText`) for this method to work. |
||||
* |
||||
* @param index Index of a `DynamicArray` item that caller `DynamicArray` |
||||
* has to return. |
||||
* @return `DynamicArray` value at `index` in the caller `DynamicArray`. |
||||
* `none` if passed `index` is invalid or non-`DynamicArray` value |
||||
* is stored there. |
||||
*/ |
||||
public final function DynamicArray GetDynamicArray(int index) |
||||
{ |
||||
return DynamicArray(GetItem(index)); |
||||
} |
||||
|
||||
defaultproperties |
||||
{ |
||||
iteratorClass = class'DynamicArrayIterator' |
||||
} |
||||
@ -1,80 +0,0 @@
|
||||
/** |
||||
* Iterator for iterating over `DynamicArray`'s items. |
||||
* Copyright 2020 Anton Tarasenko |
||||
*------------------------------------------------------------------------------ |
||||
* This file is part of Acedia. |
||||
* |
||||
* Acedia is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, version 3 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* Acedia is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||
*/ |
||||
class DynamicArrayIterator extends CollectionIterator; |
||||
|
||||
var private DynamicArray relevantCollection; |
||||
var private int currentIndex; |
||||
|
||||
protected function Finalizer() |
||||
{ |
||||
relevantCollection = none; |
||||
} |
||||
|
||||
public function bool Initialize(Collection relevantArray) |
||||
{ |
||||
currentIndex = 0; |
||||
relevantCollection = DynamicArray(relevantArray); |
||||
if (relevantCollection == none) { |
||||
return false; |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
public function Iter Next(optional bool skipNone) |
||||
{ |
||||
local int collectionLength; |
||||
if (!skipNone) |
||||
{ |
||||
currentIndex += 1; |
||||
return self; |
||||
} |
||||
collectionLength = relevantCollection.GetLength(); |
||||
while (currentIndex < collectionLength) |
||||
{ |
||||
currentIndex += 1; |
||||
if (relevantCollection.GetItem(currentIndex) != none) { |
||||
return self; |
||||
} |
||||
} |
||||
return self; |
||||
} |
||||
|
||||
public function AcediaObject Get() |
||||
{ |
||||
return relevantCollection.GetItem(currentIndex); |
||||
} |
||||
|
||||
/** |
||||
* Note that for `DynamicArrayIterator` this method produces a new `IntBox` |
||||
* object each time and requires manual deallocation. |
||||
*/ |
||||
public function AcediaObject GetKey() |
||||
{ |
||||
return _.box.int(currentIndex); |
||||
} |
||||
|
||||
public function bool HasFinished() |
||||
{ |
||||
return currentIndex >= relevantCollection.GetLength(); |
||||
} |
||||
|
||||
defaultproperties |
||||
{ |
||||
} |
||||
@ -1,488 +0,0 @@
|
||||
/** |
||||
* Set of tests for `AssociativeArray` class. |
||||
* Copyright 2020 Anton Tarasenko |
||||
*------------------------------------------------------------------------------ |
||||
* This file is part of Acedia. |
||||
* |
||||
* Acedia is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, version 3 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* Acedia is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||
*/ |
||||
class TEST_AssociativeArray extends TestCase |
||||
abstract; |
||||
|
||||
protected static function TESTS() |
||||
{ |
||||
Test_GetSet(); |
||||
Test_HasKey(); |
||||
Test_GetKeys(); |
||||
Test_CopyTextKeys(); |
||||
Test_Remove(); |
||||
Test_CreateItem(); |
||||
Test_Empty(); |
||||
Test_Length(); |
||||
Test_Managed(); |
||||
Test_DeallocationHandling(); |
||||
Test_Take(); |
||||
Test_LargeArray(); |
||||
} |
||||
|
||||
protected static function Test_GetSet() |
||||
{ |
||||
local Text textObject; |
||||
local AssociativeArray array; |
||||
array = AssociativeArray(__().memory.Allocate(class'AssociativeArray')); |
||||
|
||||
Context("Testing getters and setters for items of `AssociativeArray`."); |
||||
Issue("`SetItem()` does not correctly set new items."); |
||||
textObject = __().text.FromString("value"); |
||||
array.SetItem(__().text.FromString("key"), textObject); |
||||
array.SetItem(__().box.int(13), __().text.FromString("value #2")); |
||||
array.SetItem(__().box.float(345.2), __().box.bool(true)); |
||||
TEST_ExpectTrue( Text(array.GetItem(__().box.int(13))).ToString() |
||||
== "value #2"); |
||||
TEST_ExpectTrue(array.GetItem(__().text.FromString("key")) == textObject); |
||||
TEST_ExpectTrue(BoolBox(array.GetItem(__().box.float(345.2))).Get()); |
||||
|
||||
Issue("`SetItem()` does not correctly overwrite new items."); |
||||
array.SetItem(__().text.FromString("key"), __().text.FromString("value")); |
||||
array.SetItem(__().box.int(13), __().box.int(11)); |
||||
TEST_ExpectFalse(array.GetItem(__().text.FromString("key")) == textObject); |
||||
TEST_ExpectTrue( Text(array.GetItem(__().text.FromString("key"))) |
||||
.ToString() == "value"); |
||||
TEST_ExpectTrue( IntBox(array.GetItem(__().box.int(13))).Get() |
||||
== 11); |
||||
|
||||
Issue("`GetItem()` does not return `none` for non-existing keys."); |
||||
TEST_ExpectNone(array.GetItem(__().box.int(12))); |
||||
TEST_ExpectNone(array.GetItem(__().box.byte(67))); |
||||
TEST_ExpectNone(array.GetItem(__().box.float(43.1234))); |
||||
TEST_ExpectNone(array.GetItem(__().text.FromString("Some random stuff"))); |
||||
} |
||||
|
||||
protected static function Test_HasKey() |
||||
{ |
||||
local AssociativeArray array; |
||||
array = AssociativeArray(__().memory.Allocate(class'AssociativeArray')); |
||||
Context("Testing `HasKey()` method for `AssociativeArray`."); |
||||
array.SetItem(__().text.FromString("key"), __().text.FromString("value")); |
||||
array.SetItem(__().box.int(13), __().text.FromString("value #2")); |
||||
array.SetItem(__().box.float(345.2), __().box.bool(true)); |
||||
Issue("`HasKey()` reports that added keys do not exist in" |
||||
@ "`AssociativeArray`."); |
||||
TEST_ExpectTrue(array.HasKey(__().text.FromString("key"))); |
||||
TEST_ExpectTrue(array.HasKey(__().box.int(13))); |
||||
TEST_ExpectTrue(array.HasKey(__().box.float(345.2))); |
||||
|
||||
Issue("`HasKey()` reports that `AssociativeArray` contains keys that" |
||||
@ "were never added."); |
||||
TEST_ExpectFalse(array.HasKey(none)); |
||||
TEST_ExpectFalse(array.HasKey(__().box.float(13))); |
||||
TEST_ExpectFalse(array.HasKey(__().box.byte(139))); |
||||
} |
||||
|
||||
protected static function Test_GetKeys() |
||||
{ |
||||
local int i; |
||||
local AcediaObject key1, key2, key3; |
||||
local array<AcediaObject> keys; |
||||
local AssociativeArray array; |
||||
array = AssociativeArray(__().memory.Allocate(class'AssociativeArray')); |
||||
Context("Testing `GetKeys()` method for `AssociativeArray`."); |
||||
key1 = __().text.FromString("key"); |
||||
key2 = __().box.int(13); |
||||
key3 = __().box.float(345.2); |
||||
array.SetItem(key1, __().text.FromString("value")); |
||||
array.SetItem(key2, __().text.FromString("value #2")); |
||||
array.SetItem(key3, __().box.bool(true)); |
||||
keys = array.GetKeys(); |
||||
Issue("`GetKeys()` returns array with wrong amount of elements."); |
||||
TEST_ExpectTrue(keys.length == 3); |
||||
|
||||
Issue("`GetKeys()` returns array with duplicate keys."); |
||||
TEST_ExpectTrue(keys[0] != keys[1]); |
||||
TEST_ExpectTrue(keys[0] != keys[2]); |
||||
TEST_ExpectTrue(keys[1] != keys[2]); |
||||
|
||||
Issue("`GetKeys()` returns array with incorrect keys."); |
||||
for (i = 0; i < 3; i += 1) { |
||||
TEST_ExpectTrue(keys[i] == key1 || keys[i] == key2 || keys[i] == key3); |
||||
} |
||||
|
||||
keys = array.RemoveItem(key1).GetKeys(); |
||||
Issue("`GetKeys()` returns array with incorrect keys after removing" |
||||
@ "an element."); |
||||
TEST_ExpectTrue(keys.length == 2); |
||||
TEST_ExpectTrue(keys[0] != keys[1]); |
||||
for (i = 0; i < 2; i += 1) { |
||||
TEST_ExpectTrue(keys[i] == key2 || keys[i] == key3); |
||||
} |
||||
} |
||||
|
||||
protected static function Test_CopyTextKeys() |
||||
{ |
||||
local array<AcediaObject> allKeys; |
||||
local array<Text> keys; |
||||
local AssociativeArray array; |
||||
array = AssociativeArray(__().memory.Allocate(class'AssociativeArray')); |
||||
Context("Testing `CopyTextKeys()` method for `AssociativeArray`."); |
||||
array.SetItem(__().text.FromString("key"), __().text.FromString("value")); |
||||
array.SetItem(__().box.int(13), __().text.FromString("value #2")); |
||||
array.SetItem(__().box.float(-925.274), __().text.FromString("value #2")); |
||||
array.SetItem(__().text.FromString("second key"), __().box.bool(true)); |
||||
|
||||
Issue("`CopyTextKeys()` does not return correct set of keys."); |
||||
keys = array.CopyTextKeys(); |
||||
TEST_ExpectTrue(keys.length == 2); |
||||
TEST_ExpectTrue( |
||||
(keys[0].ToString() == "key" |
||||
&& keys[1].ToString() == "second key") |
||||
|| (keys[0].ToString() == "second key" |
||||
&& keys[1].ToString() == "key")); |
||||
|
||||
Issue("Deallocating keys returned by `CopyTextKeys()` affects their" |
||||
@ "source collection."); |
||||
allKeys = array.GetKeys(); |
||||
TEST_ExpectTrue(allKeys.length == 4); |
||||
TEST_ExpectNotNone(array.GetItem(__().text.FromString("key"))); |
||||
TEST_ExpectNotNone(array.GetItem(__().text.FromString("second key"))); |
||||
TEST_ExpectTrue( |
||||
array.GetText(__().text.FromString("key")).ToString() == "value"); |
||||
} |
||||
|
||||
protected static function Test_Remove() |
||||
{ |
||||
Context("Testing removing elements from `AssociativeArray`."); |
||||
SubTest_RemoveWithoutKeys(); |
||||
SubTest_RemoveWithKeys(); |
||||
} |
||||
|
||||
protected static function SubTest_RemoveWithoutKeys() |
||||
{ |
||||
local AcediaObject key1, key2, key3; |
||||
local array<AcediaObject> keys; |
||||
local AssociativeArray array; |
||||
array = AssociativeArray(__().memory.Allocate(class'AssociativeArray')); |
||||
key1 = __().text.FromString("some key"); |
||||
key2 = __().box.int(25); |
||||
key3 = __().box.float(0.07); |
||||
array.SetItem(key1, __().text.FromString("value")); |
||||
array.SetItem(key2, __().text.FromString("value #2")); |
||||
array.SetItem(key3, __().box.bool(true)); |
||||
Issue("Elements are not properly removed from `AssociativeArray`."); |
||||
array.RemoveItem(key1) |
||||
.RemoveItem(__().box.int(25)) |
||||
.RemoveItem(__().box.float(0.06)); |
||||
keys = array.GetKeys(); |
||||
TEST_ExpectTrue(array.GetLength() == 1); |
||||
TEST_ExpectTrue(keys.length == 1); |
||||
TEST_ExpectTrue(keys[0] == key3); |
||||
|
||||
Issue("Keys are deallocated upon removing elements from `AssociativeArray`" |
||||
@ "when they should not."); |
||||
TEST_ExpectTrue(key1.IsAllocated()); |
||||
TEST_ExpectTrue(key2.IsAllocated()); |
||||
} |
||||
|
||||
protected static function SubTest_RemoveWithKeys() |
||||
{ |
||||
local AcediaObject key1, key2, key3; |
||||
local array<AcediaObject> keys; |
||||
local AssociativeArray array; |
||||
array = AssociativeArray(__().memory.Allocate(class'AssociativeArray')); |
||||
key1 = __().text.FromString("some key"); |
||||
key2 = __().box.int(25); |
||||
key3 = __().box.float(0.07); |
||||
array.SetItem(key1, __().text.FromString("value")); |
||||
array.SetItem(key2, __().text.FromString("value #2")); |
||||
array.SetItem(key3, __().box.bool(true)); |
||||
Issue("Elements are not properly removed from `AssociativeArray`."); |
||||
array.RemoveItem(key1, true) |
||||
.RemoveItem(__().box.int(25), true) |
||||
.RemoveItem(__().box.float(0.06), true); |
||||
keys = array.GetKeys(); |
||||
TEST_ExpectTrue(array.GetLength() == 1); |
||||
TEST_ExpectTrue(keys.length == 1); |
||||
TEST_ExpectTrue(keys[0] == key3); |
||||
|
||||
Issue("Keys are not deallocated upon removing elements from" |
||||
@ "`AssociativeArray` when they should."); |
||||
TEST_ExpectFalse(key1.IsAllocated()); |
||||
TEST_ExpectFalse(key2.IsAllocated()); |
||||
} |
||||
|
||||
protected static function Test_CreateItem() |
||||
{ |
||||
local AssociativeArray array; |
||||
array = AssociativeArray(__().memory.Allocate(class'AssociativeArray')); |
||||
Context("Testing creating brand new items for `AssociativeArray`."); |
||||
Issue("`CreateItem()` incorrectly adds new values to the" |
||||
@ "`AssociativeArray`."); |
||||
array.CreateItem(__().text.FromString("key"), class'Text'); |
||||
array.CreateItem(__().box.float(17.895), class'IntRef'); |
||||
array.CreateItem(__().text.FromString("key #2"), class'BoolBox'); |
||||
TEST_ExpectTrue(Text(array.GetItem(__().text.FromString("key"))) |
||||
.ToString() == ""); |
||||
TEST_ExpectTrue( IntRef(array.GetItem(__().box.float(17.895))).Get() |
||||
== 0); |
||||
TEST_ExpectFalse(BoolBox(array.GetItem(__().text.FromString("key #2"))) |
||||
.Get()); |
||||
|
||||
Issue("`CreateItem()` incorrectly overrides existing values in the" |
||||
@ "`AssociativeArray`."); |
||||
array.SetItem(__().box.int(13), __().ref.int(7)); |
||||
array.CreateItem(__().box.int(13), class'StringRef'); |
||||
TEST_ExpectTrue( StringRef(array.GetItem(__().box.int(13))).Get() |
||||
== ""); |
||||
|
||||
class'MockItem'.default.objectCount = 0; |
||||
Issue("`CreateItem()` creates new object even if it cannot be recorded with" |
||||
@ "a given key."); |
||||
array.CreateItem(none, class'MockItem'); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 0); |
||||
} |
||||
|
||||
protected static function Test_Empty() |
||||
{ |
||||
local AcediaObject key1, key2, key3; |
||||
local AssociativeArray array; |
||||
key1 = __().text.FromString("key"); |
||||
key2 = __().box.int(13); |
||||
key3 = __().box.float(345.2); |
||||
array = AssociativeArray(__().memory.Allocate(class'AssociativeArray')); |
||||
array.SetItem(key1, __().text.FromString("value")); |
||||
array.SetItem(key2, __().text.FromString("value #2"), true); |
||||
array.SetItem(key3, __().box.bool(true)); |
||||
|
||||
Context("Testing `Empty()` method for `AssociativeArray`."); |
||||
Issue("`AssociativeArray` still contains elements after being emptied."); |
||||
array.Empty(); |
||||
TEST_ExpectTrue(array.GetKeys().length == 0); |
||||
TEST_ExpectTrue(array.GetLength() == 0); |
||||
|
||||
Issue("`AssociativeArray` deallocated keys when not being told to do so."); |
||||
TEST_ExpectTrue(key1.IsAllocated()); |
||||
TEST_ExpectTrue(key2.IsAllocated()); |
||||
TEST_ExpectTrue(key3.IsAllocated()); |
||||
|
||||
Issue("`AssociativeArray` still contains elements after being emptied."); |
||||
array.SetItem(key1, __().text.FromString("value"), true); |
||||
array.SetItem(key2, __().text.FromString("value #2")); |
||||
array.SetItem(key3, __().box.bool(true), true); |
||||
array.Empty(true); |
||||
TEST_ExpectTrue(array.GetKeys().length == 0); |
||||
TEST_ExpectTrue(array.GetLength() == 0); |
||||
|
||||
Issue("`AssociativeArray` does not deallocate keys when told to do so."); |
||||
TEST_ExpectFalse(key1.IsAllocated()); |
||||
TEST_ExpectFalse(key2.IsAllocated()); |
||||
TEST_ExpectFalse(key3.IsAllocated()); |
||||
} |
||||
|
||||
protected static function Test_Length() |
||||
{ |
||||
local AssociativeArray array; |
||||
array = AssociativeArray(__().memory.Allocate(class'AssociativeArray')); |
||||
Context("Testing computing length of `AssociativeArray`."); |
||||
Issue("Length is not zero for newly created `AssociativeArray`."); |
||||
TEST_ExpectTrue(array.GetLength() == 0); |
||||
|
||||
Issue("Length is incorrectly computed after adding elements to" |
||||
@ "`AssociativeArray`."); |
||||
array.SetItem(__().text.FromString("key"), __().text.FromString("value")); |
||||
array.SetItem(__().box.int(4563), __().text.FromString("value #2")); |
||||
array.SetItem(__().box.float(3425.243), __().box.byte(23)); |
||||
TEST_ExpectTrue(array.GetLength() == 3); |
||||
|
||||
Issue("Length is incorrectly computed after removing elements from" |
||||
@ "`AssociativeArray`."); |
||||
array.RemoveItem(__().box.int(4563)); |
||||
TEST_ExpectTrue(array.GetLength() == 2); |
||||
} |
||||
|
||||
protected static function MockItem NewMockItem() |
||||
{ |
||||
return MockItem(__().memory.Allocate(class'MockItem')); |
||||
} |
||||
|
||||
protected static function Test_Managed() |
||||
{ |
||||
local AssociativeArray array; |
||||
class'MockItem'.default.objectCount = 0; |
||||
array = AssociativeArray(__().memory.Allocate(class'AssociativeArray')); |
||||
array.SetItem(__().box.int(0), NewMockItem()); |
||||
array.SetItem(__().box.int(1), NewMockItem()); |
||||
array.SetItem(__().box.int(2), NewMockItem()); |
||||
array.SetItem(__().box.int(3), NewMockItem(), true); |
||||
array.SetItem(__().box.int(4), NewMockItem(), true); |
||||
array.SetItem(__().box.int(5), NewMockItem(), true); |
||||
array.CreateItem(__().box.int(6), class'MockItem'); |
||||
array.CreateItem(__().box.int(7), class'MockItem'); |
||||
array.CreateItem(__().box.int(8), class'MockItem'); |
||||
Context("Testing how `AssociativeArray` deallocates managed objects."); |
||||
Issue("`RemoveItem()` incorrectly deallocates managed items."); |
||||
array.RemoveItem(__().box.int(0)); |
||||
array.RemoveItem(__().box.int(3)); |
||||
array.RemoveItem(__().box.int(6)); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 7); |
||||
|
||||
Issue("Rewriting values with `SetItem()` incorrectly handles" |
||||
@ "managed items."); |
||||
array.SetItem(__().box.int(1), __().ref.int(28347)); |
||||
array.SetItem(__().box.int(4), __().ref.float(13.4)); |
||||
array.SetItem(__().box.int(7), __().ref.byte(94)); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 5); |
||||
|
||||
Issue("Rewriting values with `CreateItem()` incorrectly handles" |
||||
@ "managed items."); |
||||
array.CreateItem(__().box.int(2), class'IntRef'); |
||||
array.CreateItem(__().box.int(5), class'StringRef'); |
||||
array.CreateItem(__().box.int(8), class'IntArrayBox'); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 3); |
||||
} |
||||
|
||||
protected static function Test_DeallocationHandling() |
||||
{ |
||||
Context("Testing how `AssociativeArray` deals with external deallocation of" |
||||
@ "keys and managed objects."); |
||||
SubTest_DeallocationHandlingKeys(); |
||||
SubTest_DeallocationHandlingManagedObjects(); |
||||
} |
||||
|
||||
protected static function SubTest_DeallocationHandlingKeys() |
||||
{ |
||||
local IntBox key1; |
||||
local BoolBox key2; |
||||
local Text key3; |
||||
local AssociativeArray array; |
||||
local array<AcediaObject> keys; |
||||
key1 = __().box.int(3881); |
||||
key2 = __().box.bool(true); |
||||
key3 = __().text.FromString("Text key, bay bee"); |
||||
array = AssociativeArray(__().memory.Allocate(class'AssociativeArray')); |
||||
class'MockItem'.default.objectCount = 0; |
||||
array.SetItem(key1, NewMockItem()); |
||||
array.SetItem(key2, __().box.float(32.31), true); |
||||
array.SetItem(key3, NewMockItem(), true); |
||||
|
||||
Issue("Deallocating keys does not remove them from `AssociativeArray`."); |
||||
key1.FreeSelf(); |
||||
key3.FreeSelf(); |
||||
keys = array.GetKeys(); |
||||
TEST_ExpectTrue(keys.length == 1); |
||||
TEST_ExpectTrue(keys[0] == key2); |
||||
|
||||
Issue("`AssociativeArray` does not deallocate managed objects, even though" |
||||
@ "their keys were deallocated"); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount < 2); |
||||
TEST_ExpectNone(array.GetItem(__().box.int(3881))); |
||||
|
||||
Issue("`AssociativeArray` deallocates unmanaged objects, when" |
||||
@ "their keys were deallocated"); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount > 0); |
||||
} |
||||
|
||||
protected static function SubTest_DeallocationHandlingManagedObjects() |
||||
{ |
||||
local MockItem exampleItem; |
||||
local AssociativeArray array; |
||||
class'MockItem'.default.objectCount = 0; |
||||
exampleItem = NewMockItem(); |
||||
array = AssociativeArray(__().memory.Allocate(class'AssociativeArray')); |
||||
array.SetItem(__().box.int(-34), exampleItem, true); |
||||
array.SetItem(__().box.int(-7), exampleItem, true); |
||||
array.SetItem(__().box.int(23), NewMockItem()); |
||||
array.SetItem(__().box.int(242), NewMockItem(), true); |
||||
array.CreateItem(__().box.int(24532), class'MockItem'); |
||||
Issue("`AssociativeArray` does not return `none` even though stored object" |
||||
@ "was already deallocated."); |
||||
array.GetItem(__().box.int(23)).FreeSelf(); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 3); |
||||
TEST_ExpectTrue(array.GetItem(__().box.int(23)) == none); |
||||
|
||||
Issue("Managed items are not deallocated when they are duplicated inside" |
||||
@ "`AssociativeArray`, but they should."); |
||||
array.RemoveItem(__().box.int(-7)); |
||||
// At this point we got rid of all the managed objects that were generated |
||||
// in `array` + deallocated `exampleObject`. |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 2); |
||||
TEST_ExpectTrue(array.GetItem(__().box.int(-34)) == none); |
||||
} |
||||
|
||||
protected static function Test_Take() |
||||
{ |
||||
local AssociativeArray.Entry entry; |
||||
local AssociativeArray array; |
||||
class'MockItem'.default.objectCount = 0; |
||||
array = AssociativeArray(__().memory.Allocate(class'AssociativeArray')); |
||||
array.SetItem(__().box.int(0), NewMockItem()); |
||||
array.SetItem(__().box.int(1), NewMockItem()); |
||||
array.SetItem(__().box.int(2), NewMockItem()); |
||||
array.SetItem(__().box.int(3), NewMockItem(), true); |
||||
array.SetItem(__().box.int(4), NewMockItem(), true); |
||||
array.SetItem(__().box.int(5), NewMockItem(), true); |
||||
array.CreateItem(__().box.int(6), class'MockItem'); |
||||
array.CreateItem(__().box.int(7), class'MockItem'); |
||||
array.CreateItem(__().box.int(8), class'MockItem'); |
||||
Context("Testing `TakeItem()` method of `AssociativeArray`."); |
||||
Issue("`TakeItem()` returns incorrect value."); |
||||
TEST_ExpectTrue(array.TakeItem(__().box.int(0)).class == class'MockItem'); |
||||
TEST_ExpectTrue(array.TakeItem(__().box.int(3)).class == class'MockItem'); |
||||
TEST_ExpectTrue(array.TakeItem(__().box.int(6)).class == class'MockItem'); |
||||
|
||||
Issue("`TakeEntry()` returns incorrect value."); |
||||
entry = array.TakeEntry(__().box.int(4)); |
||||
TEST_ExpectTrue(entry.key.class == class'IntBox'); |
||||
TEST_ExpectTrue(entry.value.class == class'MockItem'); |
||||
entry = array.TakeEntry(__().box.int(7)); |
||||
TEST_ExpectTrue(entry.key.class == class'IntBox'); |
||||
TEST_ExpectTrue(entry.value.class == class'MockItem'); |
||||
|
||||
Issue("Objects returned by `Take()` and `takeEntry()` are still managed by" |
||||
@ "`AssociativeArray`."); |
||||
array.Empty(); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 7); |
||||
} |
||||
|
||||
protected static function Test_LargeArray() |
||||
{ |
||||
local int i; |
||||
local AcediaObject nextKey; |
||||
local AssociativeArray array; |
||||
Context("Testing storing large amount of elements in `AssociativeArray`."); |
||||
Issue("`AssociativeArray` cannot handle large amount of elements."); |
||||
array = AssociativeArray(__().memory.Allocate(class'AssociativeArray')); |
||||
for (i = 0; i < 2500; i += 1) { |
||||
if (i % 2 == 0) { |
||||
nextKey = __().text.FromString("var" @ i); |
||||
} |
||||
else { |
||||
nextKey = __().box.int(i * 56 - 435632); |
||||
} |
||||
array.SetItem(nextKey, __().ref.int(i)); |
||||
} |
||||
for (i = 0; i < 2500; i += 1) { |
||||
if (i % 2 == 0) { |
||||
nextKey = __().text.FromString("var" @ i); |
||||
} |
||||
else { |
||||
nextKey = __().box.int(i * 56 - 435632); |
||||
} |
||||
TEST_ExpectTrue(IntRef(array.GetItem(nextKey)).Get() == i); |
||||
} |
||||
} |
||||
|
||||
defaultproperties |
||||
{ |
||||
caseGroup = "Collections" |
||||
caseName = "AssociativeArray" |
||||
} |
||||
@ -1,322 +0,0 @@
|
||||
/** |
||||
* Set of tests for `DynamicArray` class. |
||||
* Copyright 2020 Anton Tarasenko |
||||
*------------------------------------------------------------------------------ |
||||
* This file is part of Acedia. |
||||
* |
||||
* Acedia is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, version 3 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* Acedia is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||
*/ |
||||
class TEST_DynamicArray extends TestCase |
||||
abstract; |
||||
|
||||
protected static function TESTS() |
||||
{ |
||||
Test_GetSet(); |
||||
Test_CreateItem(); |
||||
Test_Length(); |
||||
Test_Empty(); |
||||
Test_AddInsert(); |
||||
Test_Remove(); |
||||
Test_Find(); |
||||
Test_Managed(); |
||||
Test_DeallocationHandling(); |
||||
Test_Take(); |
||||
} |
||||
|
||||
protected static function Test_GetSet() |
||||
{ |
||||
local DynamicArray array; |
||||
array = DynamicArray(__().memory.Allocate(class'DynamicArray')); |
||||
Context("Testing getters and setters for items of `DynamicArray`."); |
||||
Issue("Setters do not correctly expand `DynamicArray`."); |
||||
array.SetItem(0, __().box.int(-9)).SetItem(2, __().text.FromString("text")); |
||||
TEST_ExpectTrue(array.GetLength() == 3); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(0)).Get() == -9); |
||||
TEST_ExpectNone(array.GetItem(1)); |
||||
TEST_ExpectTrue(Text(array.GetItem(2)).ToString() == "text"); |
||||
|
||||
Issue("Setters do not correctly overwrite items of `DynamicArray`."); |
||||
array.SetItem(1, __().box.float(34.76)); |
||||
array.SetItem(2, none); |
||||
TEST_ExpectTrue(array.GetLength() == 3); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(0)).Get() == -9); |
||||
TEST_ExpectTrue(FloatBox(array.GetItem(1)).Get() == 34.76); |
||||
TEST_ExpectNone(array.GetItem(2)); |
||||
} |
||||
|
||||
protected static function Test_CreateItem() |
||||
{ |
||||
local DynamicArray array; |
||||
array = DynamicArray(__().memory.Allocate(class'DynamicArray')); |
||||
Context("Testing creating brand new items for `DynamicArray`."); |
||||
Issue("`CreateItem()` incorrectly adds new values to the" |
||||
@ "`DynamicArray`."); |
||||
array.CreateItem(1, class'Text'); |
||||
array.CreateItem(3, class'IntRef'); |
||||
array.CreateItem(4, class'BoolBox'); |
||||
TEST_ExpectNone(array.GetItem(0)); |
||||
TEST_ExpectNone(array.GetItem(2)); |
||||
TEST_ExpectTrue(Text(array.GetItem(1)).ToString() == ""); |
||||
TEST_ExpectTrue(IntRef(array.GetItem(3)).Get() == 0); |
||||
TEST_ExpectFalse(BoolBox(array.GetItem(4)).Get()); |
||||
|
||||
Issue("`CreateItem()` incorrectly overrides existing values in the" |
||||
@ "`DynamicArray`."); |
||||
array.SetItem(5, __().ref.int(7)); |
||||
array.CreateItem(5, class'StringRef'); |
||||
TEST_ExpectTrue(StringRef(array.GetItem(5)).Get() == ""); |
||||
|
||||
class'MockItem'.default.objectCount = 0; |
||||
Issue("`CreateItem()` creates new object even if it cannot be recorded at" |
||||
@ "a given index."); |
||||
array.CreateItem(-1, class'MockItem'); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 0); |
||||
} |
||||
|
||||
protected static function Test_Length() |
||||
{ |
||||
local DynamicArray array; |
||||
array = DynamicArray(__().memory.Allocate(class'DynamicArray')); |
||||
Context("Testing length getter and setter for `DynamicArray`."); |
||||
Issue("Length of just created `DynamicArray` is not zero."); |
||||
TEST_ExpectTrue(array.GetLength() == 0); |
||||
|
||||
Issue("`SetLength()` incorrectly changes length of the `DynamicArray`."); |
||||
array.SetLength(200).SetItem(198, __().box.int(25)); |
||||
TEST_ExpectTrue(array.GetLength() == 200); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(198)).Get() == 25); |
||||
array.SetLength(0); |
||||
TEST_ExpectTrue(array.GetLength() == 0); |
||||
|
||||
Issue("Shrinking size of `DynamicArray` does not remove recorded items."); |
||||
array.SetLength(1000); |
||||
TEST_ExpectNone(array.GetItem(198)); |
||||
} |
||||
|
||||
protected static function Test_Empty() |
||||
{ |
||||
local DynamicArray array; |
||||
array = DynamicArray(__().memory.Allocate(class'DynamicArray')); |
||||
Context("Testing emptying `DynamicArray`."); |
||||
array.AddItem(__().box.int(1)).AddItem(__().box.int(3)) |
||||
.AddItem(__().box.int(1)).AddItem(__().box.int(3)); |
||||
Issue("`Empty()` does not produce an empty array."); |
||||
array.Empty(); |
||||
TEST_ExpectTrue(array.GetLength() == 0); |
||||
} |
||||
|
||||
protected static function Test_AddInsert() |
||||
{ |
||||
local DynamicArray array; |
||||
array = DynamicArray(__().memory.Allocate(class'DynamicArray')); |
||||
Context("Testing adding new items to `DynamicArray`."); |
||||
Issue("`Add()`/`AddItem()` incorrectly add new items to" |
||||
@ "the `DynamicArray`."); |
||||
array.AddItem(__().box.int(3)).Add(3).AddItem(__().box.byte(7)).Add(1); |
||||
TEST_ExpectTrue(array.GetLength() == 6); |
||||
TEST_ExpectNotNone(IntBox(array.GetItem(0))); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(0)).Get() == 3); |
||||
TEST_ExpectNone(array.GetItem(1)); |
||||
TEST_ExpectNone(array.GetItem(2)); |
||||
TEST_ExpectNone(array.GetItem(3)); |
||||
TEST_ExpectNotNone(ByteBox(array.GetItem(4))); |
||||
TEST_ExpectTrue(ByteBox(array.GetItem(4)).Get() == 7); |
||||
TEST_ExpectNone(array.GetItem(5)); |
||||
|
||||
Issue("`Insert()`/`InsertItem()` incorrectly add new items to" |
||||
@ "the `DynamicArray`."); |
||||
array.Insert(2, 2).InsertItem(0, __().ref.bool(true)); |
||||
TEST_ExpectTrue(array.GetLength() == 9); |
||||
TEST_ExpectNotNone(BoolRef(array.GetItem(0))); |
||||
TEST_ExpectTrue(BoolRef(array.GetItem(0)).Get()); |
||||
TEST_ExpectNotNone(IntBox(array.GetItem(1))); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(1)).Get() == 3); |
||||
TEST_ExpectNone(array.GetItem(2)); |
||||
TEST_ExpectNone(array.GetItem(6)); |
||||
TEST_ExpectNotNone(ByteBox(array.GetItem(7))); |
||||
TEST_ExpectTrue(ByteBox(array.GetItem(7)).Get() == 7); |
||||
TEST_ExpectNone(array.GetItem(8)); |
||||
} |
||||
|
||||
protected static function Test_Remove() |
||||
{ |
||||
local DynamicArray array; |
||||
array = DynamicArray(__().memory.Allocate(class'DynamicArray')); |
||||
Context("Testing removing items from `DynamicArray`."); |
||||
array.AddItem(__().box.int(1)).AddItem(__().box.int(3)) |
||||
.AddItem(__().box.int(1)).AddItem(__().box.int(3)) |
||||
.AddItem(__().box.int(5)).AddItem(__().box.int(2)) |
||||
.AddItem(__().box.int(4)).AddItem(__().box.int(7)) |
||||
.AddItem(__().box.int(5)).AddItem(__().box.int(1)) |
||||
.AddItem(__().box.int(5)).AddItem(__().box.int(0)); |
||||
Issue("`Remove()` incorrectly removes items from array."); |
||||
array.Remove(3, 2).Remove(0, 2).Remove(7, 9); |
||||
TEST_ExpectTrue(array.GetLength() == 7); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(0)).Get() == 1); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(1)).Get() == 2); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(2)).Get() == 4); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(3)).Get() == 7); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(4)).Get() == 5); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(5)).Get() == 1); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(6)).Get() == 5); |
||||
|
||||
Issue("`RemoveItem()` incorrectly removes items from array."); |
||||
array.RemoveItem(__().box.int(1)).RemoveItem(__().box.int(5), true); |
||||
TEST_ExpectTrue(array.GetLength() == 4); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(0)).Get() == 2); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(1)).Get() == 4); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(2)).Get() == 7); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(3)).Get() == 5); |
||||
|
||||
Issue("`RemoveIndex()` incorrectly removes items from array."); |
||||
array.RemoveIndex(0).RemoveIndex(1).RemoveIndex(1); |
||||
TEST_ExpectTrue(array.GetLength() == 1); |
||||
TEST_ExpectTrue(IntBox(array.GetItem(0)).Get() == 4); |
||||
} |
||||
|
||||
protected static function Test_Find() |
||||
{ |
||||
local DynamicArray array; |
||||
array = DynamicArray(__().memory.Allocate(class'DynamicArray')); |
||||
Context("Testing searching for items in `DynamicArray`."); |
||||
array.AddItem(__().box.int(1)).AddItem(__().box.int(3)) |
||||
.AddItem(__().box.int(1)).AddItem(__().box.int(3)) |
||||
.AddItem(__().box.int(5)).AddItem(__().box.bool(true)) |
||||
.AddItem(none).AddItem(__().box.float(72.54)) |
||||
.AddItem(__().box.int(5)).AddItem(__().box.int(1)) |
||||
.AddItem(__().box.int(5)).AddItem(__().box.int(0)); |
||||
Issue("`Find()` does not properly find indices of existing items."); |
||||
TEST_ExpectTrue(array.Find(__().box.int(5)) == 4); |
||||
TEST_ExpectTrue(array.Find(__().box.int(1)) == 0); |
||||
TEST_ExpectTrue(array.Find(__().box.int(0)) == 11); |
||||
TEST_ExpectTrue(array.Find(__().box.float(72.54)) == 7); |
||||
TEST_ExpectTrue(array.Find(__().box.bool(true)) == 5); |
||||
TEST_ExpectTrue(array.Find(none) == 6); |
||||
|
||||
Issue("`Find()` does not return `-1` on missing values."); |
||||
TEST_ExpectTrue(array.Find(__().box.int(42)) == -1); |
||||
TEST_ExpectTrue(array.Find(__().box.float(72.543)) == -1); |
||||
TEST_ExpectTrue(array.Find(__().box.bool(false)) == -1); |
||||
TEST_ExpectTrue(array.Find(__().box.byte(128)) == -1); |
||||
} |
||||
|
||||
protected static function MockItem NewMockItem() |
||||
{ |
||||
return MockItem(__().memory.Allocate(class'MockItem')); |
||||
} |
||||
|
||||
// Creates array with mock objects, also zeroing their count. |
||||
// Managed items' count: 6, but 12 items total. |
||||
protected static function DynamicArray NewMockArray() |
||||
{ |
||||
local DynamicArray array; |
||||
class'MockItem'.default.objectCount = 0; |
||||
array = DynamicArray(__().memory.Allocate(class'DynamicArray')); |
||||
array.AddItem(NewMockItem(), true).AddItem(NewMockItem(), false) |
||||
.InsertItem(2, NewMockItem(), true).AddItem(NewMockItem(), true) |
||||
.AddItem(NewMockItem(), false).AddItem(NewMockItem(), true) |
||||
.InsertItem(6, NewMockItem(), false).AddItem(NewMockItem(), true) |
||||
.InsertItem(3, NewMockItem(), false).AddItem(NewMockItem(), false) |
||||
.InsertItem(10, NewMockItem(), true).AddItem(NewMockItem(), false); |
||||
return array; |
||||
} |
||||
|
||||
protected static function Test_Managed() |
||||
{ |
||||
local MockItem exampleItem; |
||||
local DynamicArray array; |
||||
exampleItem = NewMockItem(); |
||||
// Managed items' count: 6, but 12 items total. |
||||
array = NewMockArray(); |
||||
Context("Testing how `DynamicArray` deallocates managed objects."); |
||||
Issue("`Remove()` incorrectly deallocates managed items."); |
||||
// -2 managed items |
||||
array.Remove(3, 2).Remove(0, 2).Remove(7, 9); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 10); |
||||
|
||||
Issue("`RemoveIndex()` incorrectly deallocates managed items."); |
||||
// -1 managed items |
||||
array.RemoveIndex(3).RemoveIndex(0); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 9); |
||||
// -1 managed items |
||||
array.RemoveItem(exampleItem, true).RemoveItem(exampleItem, true); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 8); |
||||
// -2 managed items |
||||
array.RemoveItem(exampleItem); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 6); |
||||
|
||||
array = NewMockArray(); |
||||
Issue("Shrinking array with `SetLength()` incorrectly handles" |
||||
@ "managed items"); |
||||
// -4 managed items |
||||
array.SetLength(3); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 8); |
||||
|
||||
Issue("Rewriting values with `SetItem()` incorrectly handles" |
||||
@ "managed items."); |
||||
// -2 managed items |
||||
array.SetItem(0, exampleItem, true); |
||||
array.SetItem(2, exampleItem, true); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 6); |
||||
} |
||||
|
||||
protected static function Test_DeallocationHandling() |
||||
{ |
||||
local MockItem exampleItem; |
||||
local DynamicArray array; |
||||
exampleItem = NewMockItem(); |
||||
// Managed items' count: 6, but 12 items total. |
||||
array = NewMockArray(); |
||||
Context("Testing how `DynamicArray` deals with external deallocation of" |
||||
@ "managed objects."); |
||||
Issue("`DynamicArray` does not return `none` even though stored object" |
||||
@ "was already deallocated."); |
||||
array.GetItem(0).FreeSelf(); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 11); |
||||
TEST_ExpectTrue(array.GetItem(0) == none); |
||||
|
||||
Issue("Managed items are not deallocated when they are duplicated inside" |
||||
@ "`DynamicArray`, but they should."); |
||||
array.SetItem(1, exampleItem, true).SetItem(2, exampleItem, true); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 10); |
||||
array.SetLength(2); |
||||
// At this point we got rid of all the managed objects that were generated |
||||
// in `array` + deallocated `exampleObject`. |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 5); |
||||
TEST_ExpectTrue(array.GetItem(1) == none); |
||||
} |
||||
|
||||
protected static function Test_Take() |
||||
{ |
||||
local DynamicArray array; |
||||
Context("Testing `TakeItem()` method of `DynamicArray`."); |
||||
// Managed items' count: 6, but 12 items total. |
||||
array = NewMockArray(); |
||||
Issue("`TakeItem()` returns incorrect value."); |
||||
TEST_ExpectTrue(array.TakeItem(0).class == class'MockItem'); |
||||
TEST_ExpectTrue(array.TakeItem(3).class == class'MockItem'); |
||||
TEST_ExpectTrue(array.TakeItem(4).class == class'MockItem'); |
||||
TEST_ExpectTrue(array.TakeItem(6).class == class'MockItem'); |
||||
|
||||
Issue("Objects returned by `TakeItem()` are still managed by" |
||||
@ "`DynamicArray`."); |
||||
array.Empty(); |
||||
TEST_ExpectTrue(class'MockItem'.default.objectCount == 9); |
||||
} |
||||
|
||||
defaultproperties |
||||
{ |
||||
caseGroup = "Collections" |
||||
caseName = "DynamicArray" |
||||
} |
||||
@ -1,143 +0,0 @@
|
||||
/** |
||||
* Set of tests for `Iterator` classes. |
||||
* Copyright 2020 Anton Tarasenko |
||||
*------------------------------------------------------------------------------ |
||||
* This file is part of Acedia. |
||||
* |
||||
* Acedia is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, version 3 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* Acedia is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||
*/ |
||||
class TEST_IteratorOld extends TestCase |
||||
abstract; |
||||
|
||||
var const int TESTED_ITEMS_AMOUNT; |
||||
var array<AcediaObject> items; |
||||
var array<byte> seenFlags; |
||||
|
||||
protected static function CreateItems() |
||||
{ |
||||
local int i; |
||||
ResetFlags(); |
||||
for (i = 0; i < default.TESTED_ITEMS_AMOUNT; i += 1) { |
||||
default.items[default.items.length] = __().ref.float(i*2 + 1/i); |
||||
} |
||||
} |
||||
|
||||
protected static function ResetFlags() |
||||
{ |
||||
default.seenFlags.length = 0; |
||||
default.seenFlags.length = default.TESTED_ITEMS_AMOUNT; |
||||
} |
||||
|
||||
protected static function DoTestIterator(Iter iter) |
||||
{ |
||||
local int i; |
||||
local int seenCount; |
||||
local AcediaObject nextObject; |
||||
ResetFlags(); |
||||
while (!iter.HasFinished()) |
||||
{ |
||||
nextObject = iter.Get(); |
||||
for (i = 0; i < default.items.length; i += 1) |
||||
{ |
||||
if (default.items[i] == nextObject) |
||||
{ |
||||
if (default.seenFlags[i] == 0) { |
||||
seenCount += 1; |
||||
} |
||||
default.seenFlags[i] = 1; |
||||
continue; |
||||
} |
||||
} |
||||
iter.Next(); |
||||
} |
||||
TEST_ExpectTrue(seenCount == default.TESTED_ITEMS_AMOUNT); |
||||
} |
||||
|
||||
protected static function TESTS() |
||||
{ |
||||
// Prepare |
||||
CreateItems(); |
||||
// Test |
||||
Test_DynamicArray(); |
||||
Test_AssociativeArray(); |
||||
} |
||||
|
||||
protected static function Test_DynamicArray() |
||||
{ |
||||
local int i; |
||||
local CollectionIterator iter; |
||||
local DynamicArray array; |
||||
|
||||
array = DynamicArray(__().memory.Allocate(class'DynamicArray')); |
||||
iter = array.Iterate(); |
||||
Context("Testing iterator for `DynamicArray`"); |
||||
Issue("`DynamicArray` returns `none` iterator."); |
||||
TEST_ExpectNotNone(iter); |
||||
|
||||
Issue("Iterator for empty `DynamicArray` is not finished by default."); |
||||
TEST_ExpectTrue(iter.HasFinished()); |
||||
|
||||
Issue("Iterator for empty `DynamicArray` does not return `none` as" |
||||
@ "a current item."); |
||||
TEST_ExpectNone(iter.Get()); |
||||
TEST_ExpectNone(iter.Next().Get()); |
||||
|
||||
for (i = 0; i < default.items.length; i += 1) { |
||||
array.AddItem(default.items[i]); |
||||
} |
||||
iter = array.Iterate(); |
||||
Issue("`DynamicArray` returns `none` iterator."); |
||||
TEST_ExpectNotNone(iter); |
||||
|
||||
Issue("`DynamicArray`'s iterator iterates over incorrect set of items."); |
||||
DoTestIterator(iter); |
||||
} |
||||
|
||||
protected static function Test_AssociativeArray() |
||||
{ |
||||
local int i; |
||||
local CollectionIterator iter; |
||||
local AssociativeArray array; |
||||
array = AssociativeArray(__().memory.Allocate(class'AssociativeArray')); |
||||
iter = array.Iterate(); |
||||
Context("Testing iterator for `AssociativeArray`"); |
||||
Issue("`AssociativeArray` returns `none` iterator."); |
||||
TEST_ExpectNotNone(iter); |
||||
|
||||
Issue("Iterator for empty `AssociativeArray` is not finished by default."); |
||||
TEST_ExpectTrue(iter.HasFinished()); |
||||
|
||||
Issue("Iterator for empty `AssociativeArray` does not return `none` as" |
||||
@ "a current item."); |
||||
TEST_ExpectNone(iter.Get()); |
||||
TEST_ExpectNone(iter.Next().Get()); |
||||
|
||||
for (i = 0; i < default.items.length; i += 1) { |
||||
array.SetItem(__().box.int(i), default.items[i]); |
||||
} |
||||
iter = array.Iterate(); |
||||
Issue("`AssociativeArray` returns `none` iterator."); |
||||
TEST_ExpectNotNone(iter); |
||||
|
||||
Issue("`AssociativeArray`'s iterator iterates over incorrect set of" |
||||
@ "items."); |
||||
DoTestIterator(iter); |
||||
} |
||||
|
||||
defaultproperties |
||||
{ |
||||
caseGroup = "Collections" |
||||
caseName = "IteratorOld" |
||||
TESTED_ITEMS_AMOUNT = 100 |
||||
} |
||||
Loading…
Reference in new issue