MsUnit - Now, you think with Unit Tests

You can talk about ManiaScript for ManiaPlanet here

Moderator: English Moderator

Post Reply
User avatar
Nerpson
Translator
Translator
Posts: 1555
Joined: 27 Sep 2013, 18:02
Manialink: nerpson
Location: France
Contact:
Contact Nerpson

MsUnit - Now, you think with Unit Tests

Post by Nerpson »

Dear developers,

I want to introduce you to a library I just made for one of my projects. I thought it would be nice to share it with you.
MsUnit is a library with more than 300 functions that you can use to write unit tests.

These functions allow you to:
  • Fail
  • Check Booleans
  • Match values
  • Check if values are greater / less than another one
  • Check Null or NullId values
  • Check the presence of values in arrays or maps (only Integer and Text maps)
  • Check the presence of keys in arrays or maps (only Integer and Text maps)
  • Check the presence of pairs (key + value) in arrays or maps (only Integer and Text maps)
  • Match arrays or maps (only Integer and Text maps)
Functions have been written to match most types: Boolean, Integer, Real, Int3, Vec2, Vec3, Text, CNod, Ident. Moreover, all functions are overloaded so you can add a message that will be printed out when the associated test fails.

Lists of the included functions:

Code: Select all

Void Fail(Text _FailMessage);
Void Fail();
Void Assert(Boolean _Boolean, Text _FailMessage);
Void Assert(Boolean _Boolean);
Void AssertTrue(Boolean _Boolean, Text _FailMessage);
Void AssertTrue(Boolean _Boolean);
Void AssertFalse(Boolean _Boolean, Text _FailMessage);
Void AssertFalse(Boolean _Boolean);
Void AssertEquals(Boolean _BooleanA, Boolean _BooleanB, Text _FailMessage);
Void AssertEquals(Boolean _BooleanA, Boolean _BooleanB);
Void AssertEquals(Integer _IntegerA, Integer _IntegerB, Text _FailMessage);
Void AssertEquals(Integer _IntegerA, Integer _IntegerB);
Void AssertEquals(Real _RealA, Real _RealB, Text _FailMessage);
Void AssertEquals(Real _RealA, Real _RealB);
Void AssertEquals(Int3 _Int3A, Int3 _Int3B, Text _FailMessage);
Void AssertEquals(Int3 _Int3A, Int3 _Int3B);
Void AssertEquals(Vec2 _Vec2A, Vec2 _Vec2B, Text _FailMessage);
Void AssertEquals(Vec2 _Vec2A, Vec2 _Vec2B);
Void AssertEquals(Vec3 _Vec3A, Vec3 _Vec3B, Text _FailMessage);
Void AssertEquals(Vec3 _Vec3A, Vec3 _Vec3B);
Void AssertEquals(Text _TextA, Text _TextB, Text _FailMessage);
Void AssertEquals(Text _TextA, Text _TextB);
Void AssertEquals(CNod _ObjectA, CNod _ObjectB, Text _FailMessage);
Void AssertEquals(CNod _ObjectA, CNod _ObjectB);
Void AssertEquals(Ident _IdentA, Ident _IdentB, Text _FailMessage);
Void AssertEquals(Ident _IdentA, Ident _IdentB);
Void AssertNotEquals(Boolean _BooleanA, Boolean _BooleanB, Text _FailMessage);
Void AssertNotEquals(Boolean _BooleanA, Boolean _BooleanB);
Void AssertNotEquals(Integer _IntegerA, Integer _IntegerB, Text _FailMessage);
Void AssertNotEquals(Integer _IntegerA, Integer _IntegerB);
Void AssertNotEquals(Real _RealA, Real _RealB, Text _FailMessage);
Void AssertNotEquals(Real _RealA, Real _RealB);
Void AssertNotEquals(Int3 _Int3A, Int3 _Int3B, Text _FailMessage);
Void AssertNotEquals(Int3 _Int3A, Int3 _Int3B);
Void AssertNotEquals(Vec2 _Vec2A, Vec2 _Vec2B, Text _FailMessage);
Void AssertNotEquals(Vec2 _Vec2A, Vec2 _Vec2B);
Void AssertNotEquals(Vec3 _Vec3A, Vec3 _Vec3B, Text _FailMessage);
Void AssertNotEquals(Vec3 _Vec3A, Vec3 _Vec3B);
Void AssertNotEquals(Text _TextA, Text _TextB, Text _FailMessage);
Void AssertNotEquals(Text _TextA, Text _TextB);
Void AssertNotEquals(CNod _ObjectA, CNod _ObjectB, Text _FailMessage);
Void AssertNotEquals(CNod _ObjectA, CNod _ObjectB);
Void AssertNotEquals(Ident _IdentA, Ident _IdentB, Text _FailMessage);
Void AssertNotEquals(Ident _IdentA, Ident _IdentB);
Void AssertGreater(Integer _IntegerA, Integer _IntegerB, Text _FailMessage);
Void AssertGreater(Integer _IntegerA, Integer _IntegerB);
Void AssertGreater(Real _RealA, Real _RealB, Text _FailMessage);
Void AssertGreater(Real _RealA, Real _RealB);
Void AssertGreater(Int3 _Int3A, Int3 _Int3B, Text _FailMessage);
Void AssertGreater(Int3 _Int3A, Int3 _Int3B);
Void AssertGreater(Vec2 _Vec2A, Vec2 _Vec2B, Text _FailMessage);
Void AssertGreater(Vec2 _Vec2A, Vec2 _Vec2B);
Void AssertGreater(Vec3 _Vec3A, Vec3 _Vec3B, Text _FailMessage);
Void AssertGreater(Vec3 _Vec3A, Vec3 _Vec3B);
Void AssertGreaterOrEquals(Integer _IntegerA, Integer _IntegerB, Text _FailMessage);
Void AssertGreaterOrEquals(Integer _IntegerA, Integer _IntegerB);
Void AssertGreaterOrEquals(Real _RealA, Real _RealB, Text _FailMessage);
Void AssertGreaterOrEquals(Real _RealA, Real _RealB);
Void AssertGreaterOrEquals(Int3 _Int3A, Int3 _Int3B, Text _FailMessage);
Void AssertGreaterOrEquals(Int3 _Int3A, Int3 _Int3B);
Void AssertGreaterOrEquals(Vec2 _Vec2A, Vec2 _Vec2B, Text _FailMessage);
Void AssertGreaterOrEquals(Vec2 _Vec2A, Vec2 _Vec2B);
Void AssertGreaterOrEquals(Vec3 _Vec3A, Vec3 _Vec3B, Text _FailMessage);
Void AssertGreaterOrEquals(Vec3 _Vec3A, Vec3 _Vec3B);
Void AssertLess(Integer _IntegerA, Integer _IntegerB, Text _FailMessage);
Void AssertLess(Integer _IntegerA, Integer _IntegerB);
Void AssertLess(Real _RealA, Real _RealB, Text _FailMessage);
Void AssertLess(Real _RealA, Real _RealB);
Void AssertLess(Int3 _Int3A, Int3 _Int3B, Text _FailMessage);
Void AssertLess(Int3 _Int3A, Int3 _Int3B);
Void AssertLess(Vec2 _Vec2A, Vec2 _Vec2B, Text _FailMessage);
Void AssertLess(Vec2 _Vec2A, Vec2 _Vec2B);
Void AssertLess(Vec3 _Vec3A, Vec3 _Vec3B, Text _FailMessage);
Void AssertLess(Vec3 _Vec3A, Vec3 _Vec3B);
Void AssertLessOrEquals(Integer _IntegerA, Integer _IntegerB, Text _FailMessage);
Void AssertLessOrEquals(Integer _IntegerA, Integer _IntegerB);
Void AssertLessOrEquals(Real _RealA, Real _RealB, Text _FailMessage);
Void AssertLessOrEquals(Real _RealA, Real _RealB);
Void AssertLessOrEquals(Int3 _Int3A, Int3 _Int3B, Text _FailMessage);
Void AssertLessOrEquals(Int3 _Int3A, Int3 _Int3B);
Void AssertLessOrEquals(Vec2 _Vec2A, Vec2 _Vec2B, Text _FailMessage);
Void AssertLessOrEquals(Vec2 _Vec2A, Vec2 _Vec2B);
Void AssertLessOrEquals(Vec3 _Vec3A, Vec3 _Vec3B, Text _FailMessage);
Void AssertLessOrEquals(Vec3 _Vec3A, Vec3 _Vec3B);
Void AssertNull(CNod _Object, Text _FailMessage);
Void AssertNull(CNod _Object);
Void AssertNotNull(CNod _Object, Text _FailMessage);
Void AssertNotNull(CNod _Object);
Void AssertNullId(Ident _Ident, Text _FailMessage);
Void AssertNullId(Ident _Ident);
Void AssertNotNullId(Ident _Ident, Text _FailMessage);
Void AssertNotNullId(Ident _Ident);
Void AssertArrayContainsValue(Boolean[] _Array, Boolean _Boolean, Text _FailMessage);
Void AssertArrayContainsValue(Boolean[] _Array, Boolean _Boolean);
Void AssertArrayContainsValue(Integer[] _Array, Integer _Integer, Text _FailMessage);
Void AssertArrayContainsValue(Integer[] _Array, Integer _Integer);
Void AssertArrayContainsValue(Real[] _Array, Real _Real, Text _FailMessage);
Void AssertArrayContainsValue(Real[] _Array, Real _Real);
Void AssertArrayContainsValue(Int3[] _Array, Int3 _Int3, Text _FailMessage);
Void AssertArrayContainsValue(Int3[] _Array, Int3 _Int3);
Void AssertArrayContainsValue(Vec2[] _Array, Vec2 _Vec2, Text _FailMessage);
Void AssertArrayContainsValue(Vec2[] _Array, Vec2 _Vec2);
Void AssertArrayContainsValue(Vec3[] _Array, Vec3 _Vec3, Text _FailMessage);
Void AssertArrayContainsValue(Vec3[] _Array, Vec3 _Vec3);
Void AssertArrayContainsValue(Text[] _Array, Text _Text, Text _FailMessage);
Void AssertArrayContainsValue(Text[] _Array, Text _Text);
Void AssertArrayContainsValue(CNod[] _Array, CNod _Object, Text _FailMessage);
Void AssertArrayContainsValue(CNod[] _Array, CNod _Object);
Void AssertArrayContainsValue(Ident[] _Array, Ident _Ident, Text _FailMessage);
Void AssertArrayContainsValue(Ident[] _Array, Ident _Ident);
Void AssertArrayContainsValue(Boolean[Integer] _Array, Boolean _Boolean, Text _FailMessage);
Void AssertArrayContainsValue(Boolean[Integer] _Array, Boolean _Boolean);
Void AssertArrayContainsValue(Integer[Integer] _Array, Integer _Integer, Text _FailMessage);
Void AssertArrayContainsValue(Integer[Integer] _Array, Integer _Integer);
Void AssertArrayContainsValue(Real[Integer] _Array, Real _Real, Text _FailMessage);
Void AssertArrayContainsValue(Real[Integer] _Array, Real _Real);
Void AssertArrayContainsValue(Int3[Integer] _Array, Int3 _Int3, Text _FailMessage);
Void AssertArrayContainsValue(Int3[Integer] _Array, Int3 _Int3);
Void AssertArrayContainsValue(Vec2[Integer] _Array, Vec2 _Vec2, Text _FailMessage);
Void AssertArrayContainsValue(Vec2[Integer] _Array, Vec2 _Vec2);
Void AssertArrayContainsValue(Vec3[Integer] _Array, Vec3 _Vec3, Text _FailMessage);
Void AssertArrayContainsValue(Vec3[Integer] _Array, Vec3 _Vec3);
Void AssertArrayContainsValue(Text[Integer] _Array, Text _Text, Text _FailMessage);
Void AssertArrayContainsValue(Text[Integer] _Array, Text _Text);
Void AssertArrayContainsValue(CNod[Integer] _Array, CNod _Object, Text _FailMessage);
Void AssertArrayContainsValue(CNod[Integer] _Array, CNod _Object);
Void AssertArrayContainsValue(Ident[Integer] _Array, Ident _Ident, Text _FailMessage);
Void AssertArrayContainsValue(Ident[Integer] _Array, Ident _Ident);
Void AssertArrayContainsValue(Boolean[Text] _Array, Boolean _Boolean, Text _FailMessage);
Void AssertArrayContainsValue(Boolean[Text] _Array, Boolean _Boolean);
Void AssertArrayContainsValue(Integer[Text] _Array, Integer _Integer, Text _FailMessage);
Void AssertArrayContainsValue(Integer[Text] _Array, Integer _Integer);
Void AssertArrayContainsValue(Real[Text] _Array, Real _Real, Text _FailMessage);
Void AssertArrayContainsValue(Real[Text] _Array, Real _Real);
Void AssertArrayContainsValue(Int3[Text] _Array, Int3 _Int3, Text _FailMessage);
Void AssertArrayContainsValue(Int3[Text] _Array, Int3 _Int3);
Void AssertArrayContainsValue(Vec2[Text] _Array, Vec2 _Vec2, Text _FailMessage);
Void AssertArrayContainsValue(Vec2[Text] _Array, Vec2 _Vec2);
Void AssertArrayContainsValue(Vec3[Text] _Array, Vec3 _Vec3, Text _FailMessage);
Void AssertArrayContainsValue(Vec3[Text] _Array, Vec3 _Vec3);
Void AssertArrayContainsValue(Text[Text] _Array, Text _Text, Text _FailMessage);
Void AssertArrayContainsValue(Text[Text] _Array, Text _Text);
Void AssertArrayContainsValue(CNod[Text] _Array, CNod _Object, Text _FailMessage);
Void AssertArrayContainsValue(CNod[Text] _Array, CNod _Object);
Void AssertArrayContainsValue(Ident[Text] _Array, Ident _Ident, Text _FailMessage);
Void AssertArrayContainsValue(Ident[Text] _Array, Ident _Ident);
Void AssertArrayContainsKey(Boolean[] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Boolean[] _Array, Integer _Key);
Void AssertArrayContainsKey(Integer[] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Integer[] _Array, Integer _Key);
Void AssertArrayContainsKey(Real[] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Real[] _Array, Integer _Key);
Void AssertArrayContainsKey(Int3[] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Int3[] _Array, Integer _Key);
Void AssertArrayContainsKey(Vec2[] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Vec2[] _Array, Integer _Key);
Void AssertArrayContainsKey(Vec3[] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Vec3[] _Array, Integer _Key);
Void AssertArrayContainsKey(Text[] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Text[] _Array, Integer _Key);
Void AssertArrayContainsKey(CNod[] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(CNod[] _Array, Integer _Key);
Void AssertArrayContainsKey(Ident[] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Ident[] _Array, Integer _Key);
Void AssertArrayContainsKey(Boolean[Integer] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Boolean[Integer] _Array, Integer _Key);
Void AssertArrayContainsKey(Integer[Integer] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Integer[Integer] _Array, Integer _Key);
Void AssertArrayContainsKey(Real[Integer] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Real[Integer] _Array, Integer _Key);
Void AssertArrayContainsKey(Int3[Integer] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Int3[Integer] _Array, Integer _Key);
Void AssertArrayContainsKey(Vec2[Integer] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Vec2[Integer] _Array, Integer _Key);
Void AssertArrayContainsKey(Vec3[Integer] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Vec3[Integer] _Array, Integer _Key);
Void AssertArrayContainsKey(Text[Integer] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Text[Integer] _Array, Integer _Key);
Void AssertArrayContainsKey(CNod[Integer] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(CNod[Integer] _Array, Integer _Key);
Void AssertArrayContainsKey(Ident[Integer] _Array, Integer _Key, Text _FailMessage);
Void AssertArrayContainsKey(Ident[Integer] _Array, Integer _Key);
Void AssertArrayContainsKey(Boolean[Text] _Array, Text _Key, Text _FailMessage);
Void AssertArrayContainsKey(Boolean[Text] _Array, Text _Key);
Void AssertArrayContainsKey(Integer[Text] _Array, Text _Key, Text _FailMessage);
Void AssertArrayContainsKey(Integer[Text] _Array, Text _Key);
Void AssertArrayContainsKey(Real[Text] _Array, Text _Key, Text _FailMessage);
Void AssertArrayContainsKey(Real[Text] _Array, Text _Key);
Void AssertArrayContainsKey(Int3[Text] _Array, Text _Key, Text _FailMessage);
Void AssertArrayContainsKey(Int3[Text] _Array, Text _Key);
Void AssertArrayContainsKey(Vec2[Text] _Array, Text _Key, Text _FailMessage);
Void AssertArrayContainsKey(Vec2[Text] _Array, Text _Key);
Void AssertArrayContainsKey(Vec3[Text] _Array, Text _Key, Text _FailMessage);
Void AssertArrayContainsKey(Vec3[Text] _Array, Text _Key);
Void AssertArrayContainsKey(Text[Text] _Array, Text _Key, Text _FailMessage);
Void AssertArrayContainsKey(Text[Text] _Array, Text _Key);
Void AssertArrayContainsKey(CNod[Text] _Array, Text _Key, Text _FailMessage);
Void AssertArrayContainsKey(CNod[Text] _Array, Text _Key);
Void AssertArrayContainsKey(Ident[Text] _Array, Text _Key, Text _FailMessage);
Void AssertArrayContainsKey(Ident[Text] _Array, Text _Key);
Void AssertArrayContains(Boolean[] _Array, Integer _Key, Boolean _BooleanValue, Text _FailMessage);
Void AssertArrayContains(Boolean[] _Array, Integer _Key, Boolean _BooleanValue);
Void AssertArrayContains(Integer[] _Array, Integer _Key, Integer _IntegerValue, Text _FailMessage);
Void AssertArrayContains(Integer[] _Array, Integer _Key, Integer _IntegerValue);
Void AssertArrayContains(Real[] _Array, Integer _Key, Real _RealValue, Text _FailMessage);
Void AssertArrayContains(Real[] _Array, Integer _Key, Real _RealValue);
Void AssertArrayContains(Int3[] _Array, Integer _Key, Int3 _Int3Value, Text _FailMessage);
Void AssertArrayContains(Int3[] _Array, Integer _Key, Int3 _Int3Value);
Void AssertArrayContains(Vec2[] _Array, Integer _Key, Vec2 _Vec2Value, Text _FailMessage);
Void AssertArrayContains(Vec2[] _Array, Integer _Key, Vec2 _Vec2Value);
Void AssertArrayContains(Vec3[] _Array, Integer _Key, Vec3 _Vec3Value, Text _FailMessage);
Void AssertArrayContains(Vec3[] _Array, Integer _Key, Vec3 _Vec3Value);
Void AssertArrayContains(Text[] _Array, Integer _Key, Text _TextValue, Text _FailMessage);
Void AssertArrayContains(Text[] _Array, Integer _Key, Text _TextValue);
Void AssertArrayContains(CNod[] _Array, Integer _Key, CNod _ObjectValue, Text _FailMessage);
Void AssertArrayContains(CNod[] _Array, Integer _Key, CNod _ObjectValue);
Void AssertArrayContains(Ident[] _Array, Integer _Key, Ident _IdentValue, Text _FailMessage);
Void AssertArrayContains(Ident[] _Array, Integer _Key, Ident _IdentValue);
Void AssertArrayContains(Boolean[Integer] _Array, Integer _Key, Boolean _BooleanValue, Text _FailMessage);
Void AssertArrayContains(Boolean[Integer] _Array, Integer _Key, Boolean _BooleanValue);
Void AssertArrayContains(Integer[Integer] _Array, Integer _Key, Integer _IntegerValue, Text _FailMessage);
Void AssertArrayContains(Integer[Integer] _Array, Integer _Key, Integer _IntegerValue);
Void AssertArrayContains(Real[Integer] _Array, Integer _Key, Real _RealValue, Text _FailMessage);
Void AssertArrayContains(Real[Integer] _Array, Integer _Key, Real _RealValue);
Void AssertArrayContains(Int3[Integer] _Array, Integer _Key, Int3 _Int3Value, Text _FailMessage);
Void AssertArrayContains(Int3[Integer] _Array, Integer _Key, Int3 _Int3Value);
Void AssertArrayContains(Vec2[Integer] _Array, Integer _Key, Vec2 _Vec2Value, Text _FailMessage);
Void AssertArrayContains(Vec2[Integer] _Array, Integer _Key, Vec2 _Vec2Value);
Void AssertArrayContains(Vec3[Integer] _Array, Integer _Key, Vec3 _Vec3Value, Text _FailMessage);
Void AssertArrayContains(Vec3[Integer] _Array, Integer _Key, Vec3 _Vec3Value);
Void AssertArrayContains(Text[Integer] _Array, Integer _Key, Text _TextValue, Text _FailMessage);
Void AssertArrayContains(Text[Integer] _Array, Integer _Key, Text _TextValue);
Void AssertArrayContains(CNod[Integer] _Array, Integer _Key, CNod _ObjectValue, Text _FailMessage);
Void AssertArrayContains(CNod[Integer] _Array, Integer _Key, CNod _ObjectValue);
Void AssertArrayContains(Ident[Integer] _Array, Integer _Key, Ident _IdentValue, Text _FailMessage);
Void AssertArrayContains(Ident[Integer] _Array, Integer _Key, Ident _IdentValue);
Void AssertArrayContains(Boolean[Text] _Array, Text _Key, Boolean _BooleanValue, Text _FailMessage);
Void AssertArrayContains(Boolean[Text] _Array, Text _Key, Boolean _BooleanValue);
Void AssertArrayContains(Integer[Text] _Array, Text _Key, Integer _IntegerValue, Text _FailMessage);
Void AssertArrayContains(Integer[Text] _Array, Text _Key, Integer _IntegerValue);
Void AssertArrayContains(Real[Text] _Array, Text _Key, Real _RealValue, Text _FailMessage);
Void AssertArrayContains(Real[Text] _Array, Text _Key, Real _RealValue);
Void AssertArrayContains(Int3[Text] _Array, Text _Key, Int3 _Int3Value, Text _FailMessage);
Void AssertArrayContains(Int3[Text] _Array, Text _Key, Int3 _Int3Value);
Void AssertArrayContains(Vec2[Text] _Array, Text _Key, Vec2 _Vec2Value, Text _FailMessage);
Void AssertArrayContains(Vec2[Text] _Array, Text _Key, Vec2 _Vec2Value);
Void AssertArrayContains(Vec3[Text] _Array, Text _Key, Vec3 _Vec3Value, Text _FailMessage);
Void AssertArrayContains(Vec3[Text] _Array, Text _Key, Vec3 _Vec3Value);
Void AssertArrayContains(Text[Text] _Array, Text _Key, Text _TextValue, Text _FailMessage);
Void AssertArrayContains(Text[Text] _Array, Text _Key, Text _TextValue);
Void AssertArrayContains(CNod[Text] _Array, Text _Key, CNod _ObjectValue, Text _FailMessage);
Void AssertArrayContains(CNod[Text] _Array, Text _Key, CNod _ObjectValue);
Void AssertArrayContains(Ident[Text] _Array, Text _Key, Ident _IdentValue, Text _FailMessage);
Void AssertArrayContains(Ident[Text] _Array, Text _Key, Ident _IdentValue);
Void AssertArrayEquals(Boolean[] _ArrayA, Boolean[] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Boolean[] _ArrayA, Boolean[] _ArrayB);
Void AssertArrayEquals(Integer[] _ArrayA, Integer[] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Integer[] _ArrayA, Integer[] _ArrayB);
Void AssertArrayEquals(Real[] _ArrayA, Real[] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Real[] _ArrayA, Real[] _ArrayB);
Void AssertArrayEquals(Int3[] _ArrayA, Int3[] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Int3[] _ArrayA, Int3[] _ArrayB);
Void AssertArrayEquals(Vec2[] _ArrayA, Vec2[] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Vec2[] _ArrayA, Vec2[] _ArrayB);
Void AssertArrayEquals(Vec3[] _ArrayA, Vec3[] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Vec3[] _ArrayA, Vec3[] _ArrayB);
Void AssertArrayEquals(Text[] _ArrayA, Text[] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Text[] _ArrayA, Text[] _ArrayB);
Void AssertArrayEquals(CNod[] _ArrayA, CNod[] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(CNod[] _ArrayA, CNod[] _ArrayB);
Void AssertArrayEquals(Ident[] _ArrayA, Ident[] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Ident[] _ArrayA, Ident[] _ArrayB);
Void AssertArrayEquals(Boolean[Integer] _ArrayA, Boolean[Integer] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Boolean[Integer] _ArrayA, Boolean[Integer] _ArrayB);
Void AssertArrayEquals(Integer[Integer] _ArrayA, Integer[Integer] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Integer[Integer] _ArrayA, Integer[Integer] _ArrayB);
Void AssertArrayEquals(Real[Integer] _ArrayA, Real[Integer] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Real[Integer] _ArrayA, Real[Integer] _ArrayB);
Void AssertArrayEquals(Int3[Integer] _ArrayA, Int3[Integer] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Int3[Integer] _ArrayA, Int3[Integer] _ArrayB);
Void AssertArrayEquals(Vec2[Integer] _ArrayA, Vec2[Integer] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Vec2[Integer] _ArrayA, Vec2[Integer] _ArrayB);
Void AssertArrayEquals(Text[Integer] _ArrayA, Text[Integer] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Text[Integer] _ArrayA, Text[Integer] _ArrayB);
Void AssertArrayEquals(CNod[Integer] _ArrayA, CNod[Integer] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(CNod[Integer] _ArrayA, CNod[Integer] _ArrayB);
Void AssertArrayEquals(Ident[Integer] _ArrayA, Ident[Integer] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Ident[Integer] _ArrayA, Ident[Integer] _ArrayB);
Void AssertArrayEquals(Boolean[Text] _ArrayA, Boolean[Text] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Boolean[Text] _ArrayA, Boolean[Text] _ArrayB);
Void AssertArrayEquals(Integer[Text] _ArrayA, Integer[Text] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Integer[Text] _ArrayA, Integer[Text] _ArrayB);
Void AssertArrayEquals(Real[Text] _ArrayA, Real[Text] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Real[Text] _ArrayA, Real[Text] _ArrayB);
Void AssertArrayEquals(Int3[Text] _ArrayA, Int3[Text] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Int3[Text] _ArrayA, Int3[Text] _ArrayB);
Void AssertArrayEquals(Vec2[Text] _ArrayA, Vec2[Text] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Vec2[Text] _ArrayA, Vec2[Text] _ArrayB);
Void AssertArrayEquals(Text[Text] _ArrayA, Text[Text] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Text[Text] _ArrayA, Text[Text] _ArrayB);
Void AssertArrayEquals(CNod[Text] _ArrayA, CNod[Text] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(CNod[Text] _ArrayA, CNod[Text] _ArrayB);
Void AssertArrayEquals(Ident[Text] _ArrayA, Ident[Text] _ArrayB, Text _FailMessage);
Void AssertArrayEquals(Ident[Text] _ArrayA, Ident[Text] _ArrayB);
You will find the library on my Github repository.
Get it here

If you have any questions, feel free to ask them. If you find any issue with my code, please open an issue report on my Github repository.

Now, you think with Unit Tests.
ImageImageImageImage
Top
Post Reply

Return to “ManiaScript”

Who is online

Users browsing this forum: No registered users and 2 guests