public static void rol_uint8()
{
bool result = true;
Random32 rng = new Random32(RNG_SEED);
for (int i = 0; i < UInt8.NUM_TESTS; i++)
{
for (int j = 0; j < NUM_ROTATION_TESTS; j++)
{
int n = rng.NextInt();
uint8 test = maxmath.rol(UInt8.TestData_LHS[i], n);
result &= test.x0 == math.rol(UInt8.TestData_LHS[i].x0, n);
result &= test.x1 == math.rol(UInt8.TestData_LHS[i].x1, n);
result &= test.x2 == math.rol(UInt8.TestData_LHS[i].x2, n);
result &= test.x3 == math.rol(UInt8.TestData_LHS[i].x3, n);
result &= test.x4 == math.rol(UInt8.TestData_LHS[i].x4, n);
result &= test.x5 == math.rol(UInt8.TestData_LHS[i].x5, n);
result &= test.x6 == math.rol(UInt8.TestData_LHS[i].x6, n);
result &= test.x7 == math.rol(UInt8.TestData_LHS[i].x7, n);
}
}
Assert.AreEqual(true, result);
}
public static void Constructor_UInt()
{
uint8 x = new uint8(TestData_LHS[0].x0);
Assert.AreEqual(x.x0 == TestData_LHS[0].x0 &
x.x1 == TestData_LHS[0].x0 &
x.x2 == TestData_LHS[0].x0 &
x.x3 == TestData_LHS[0].x0 &
x.x4 == TestData_LHS[0].x0 &
x.x5 == TestData_LHS[0].x0 &
x.x6 == TestData_LHS[0].x0 &
x.x7 == TestData_LHS[0].x0, true);
}
public static void Constructor_UInt_UInt_UInt_UInt_UInt_UInt_UInt_UInt()
{
uint8 x = new uint8(TestData_LHS[0].x0, TestData_LHS[0].x1, TestData_LHS[0].x2, TestData_LHS[0].x3, TestData_LHS[0].x4, TestData_LHS[0].x5, TestData_LHS[0].x6, TestData_LHS[0].x7);
Assert.AreEqual(x.x0 == TestData_LHS[0].x0 &
x.x1 == TestData_LHS[0].x1 &
x.x2 == TestData_LHS[0].x2 &
x.x3 == TestData_LHS[0].x3 &
x.x4 == TestData_LHS[0].x4 &
x.x5 == TestData_LHS[0].x5 &
x.x6 == TestData_LHS[0].x6 &
x.x7 == TestData_LHS[0].x7, true);
}
public static void uint8()
{
for (int i = 0; i < UInt8.TestData_LHS.Length; i++)
{
for (int j = 1; j < 8; j++)
{
uint8 shl = maxmath.vshl(UInt8.TestData_LHS[i], j);
for (int k = 0; k < 8; k++)
{
Assert.IsTrue(shl[k] == ((k - j < 0) ? 0 : UInt8.TestData_LHS[i][k - j]));
}
}
}
}
public static void uint8()
{
for (int i = 0; i < UInt8.TestData_LHS.Length; i++)
{
for (int j = 1; j < 8; j++)
{
uint8 rol = maxmath.vrol(UInt8.TestData_LHS[i], j);
for (int k = 0; k < 8; k++)
{
Assert.AreEqual(rol[k], UInt8.TestData_LHS[i][((8 - j) + k) % 8]);
}
}
}
}
public static void uint8()
{
for (int i = 0; i < UInt8.TestData_LHS.Length; i++)
{
for (int j = 1; j < 8; j++)
{
uint8 shr = maxmath.vshr(UInt8.TestData_LHS[i], j);
for (int k = 0; k < 8; k++)
{
Assert.IsTrue(shr[k] == ((j + k >= 8) ? 0 : UInt8.TestData_LHS[i][j + k]));
}
}
}
}
public static void uint8()
{
Random32 rng = new Random32(135);
for (uint i = 0; i < 64; i++)
{
uint8 x = rng.NextUInt8();
Assert.AreEqual(new uint8((uint)_intsqrt(x.x0),
(uint)_intsqrt(x.x1),
(uint)_intsqrt(x.x2),
(uint)_intsqrt(x.x3),
(uint)_intsqrt(x.x4),
(uint)_intsqrt(x.x5),
(uint)_intsqrt(x.x6),
(uint)_intsqrt(x.x7)),
maxmath.intsqrt(x));
}
}
private void AssignFromData(ReadOnlySpan <byte> data)
{
Data0 = data[0];
Data1 = data[1];
Data2 = data[2];
Data3 = data[3];
Data4 = data[4];
Data5 = data[5];
Data6 = data[6];
Data7 = data[7];
Data8 = data[8];
Data9 = data[9];
Data10 = data[10];
Data11 = data[11];
Data12 = data[12];
Data13 = data[13];
Data14 = data[14];
Data15 = data[15];
}
public static void int8()
{
Random32 rng = new Random32(135);
for (int i = 0; i < 64; i++)
{
int8 x = rng.NextInt8();
uint8 n = rng.NextUInt8();
Assert.AreEqual(new int8((int)_intpow(x.x0, n.x0),
(int)_intpow(x.x1, n.x1),
(int)_intpow(x.x2, n.x2),
(int)_intpow(x.x3, n.x3),
(int)_intpow(x.x4, n.x4),
(int)_intpow(x.x5, n.x5),
(int)_intpow(x.x6, n.x6),
(int)_intpow(x.x7, n.x7)),
maxmath.intpow(x, n));
}
}
public static void uint8()
{
Random32 rng = new Random32(135);
for (uint i = 0; i < 64; i++)
{
uint8 x = rng.NextUInt8();
uint8 y = rng.NextUInt8();
Assert.AreEqual(new uint8((uint)_gcd(x.x0, y.x0),
(uint)_gcd(x.x1, y.x1),
(uint)_gcd(x.x2, y.x2),
(uint)_gcd(x.x3, y.x3),
(uint)_gcd(x.x4, y.x4),
(uint)_gcd(x.x5, y.x5),
(uint)_gcd(x.x6, y.x6),
(uint)_gcd(x.x7, y.x7)),
maxmath.gcd(x, y));
}
}
public static void Cast_ToUInt()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
uint8 x = TestData_LHS[i];
result &= x.x0 == TestData_LHS[i].x0 &
x.x1 == TestData_LHS[i].x1 &
x.x2 == TestData_LHS[i].x2 &
x.x3 == TestData_LHS[i].x3 &
x.x4 == TestData_LHS[i].x4 &
x.x5 == TestData_LHS[i].x5 &
x.x6 == TestData_LHS[i].x6 &
x.x7 == TestData_LHS[i].x7;
}
Assert.AreEqual(true, result);
}
public static void Multiply()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
uint8 x = TestData_LHS[i] * TestData_RHS[i];
result &= x.x0 == (uint)(TestData_LHS[i].x0 * TestData_RHS[i].x0) &
x.x1 == (uint)(TestData_LHS[i].x1 * TestData_RHS[i].x1) &
x.x2 == (uint)(TestData_LHS[i].x2 * TestData_RHS[i].x2) &
x.x3 == (uint)(TestData_LHS[i].x3 * TestData_RHS[i].x3) &
x.x4 == (uint)(TestData_LHS[i].x4 * TestData_RHS[i].x4) &
x.x5 == (uint)(TestData_LHS[i].x5 * TestData_RHS[i].x5) &
x.x6 == (uint)(TestData_LHS[i].x6 * TestData_RHS[i].x6) &
x.x7 == (uint)(TestData_LHS[i].x7 * TestData_RHS[i].x7);
}
Assert.AreEqual(true, result);
}
public static void Subtract()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
uint8 x = TestData_LHS[i] - TestData_RHS[i];
result &= x.x0 == (uint)(TestData_LHS[i].x0 - TestData_RHS[i].x0) &
x.x1 == (uint)(TestData_LHS[i].x1 - TestData_RHS[i].x1) &
x.x2 == (uint)(TestData_LHS[i].x2 - TestData_RHS[i].x2) &
x.x3 == (uint)(TestData_LHS[i].x3 - TestData_RHS[i].x3) &
x.x4 == (uint)(TestData_LHS[i].x4 - TestData_RHS[i].x4) &
x.x5 == (uint)(TestData_LHS[i].x5 - TestData_RHS[i].x5) &
x.x6 == (uint)(TestData_LHS[i].x6 - TestData_RHS[i].x6) &
x.x7 == (uint)(TestData_LHS[i].x7 - TestData_RHS[i].x7);
}
Assert.AreEqual(true, result);
}
public static void NOT()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
uint8 x = ~TestData_LHS[i];
result &= x.x0 == (uint)(~TestData_LHS[i].x0) &
x.x1 == (uint)(~TestData_LHS[i].x1) &
x.x2 == (uint)(~TestData_LHS[i].x2) &
x.x3 == (uint)(~TestData_LHS[i].x3) &
x.x4 == (uint)(~TestData_LHS[i].x4) &
x.x5 == (uint)(~TestData_LHS[i].x5) &
x.x6 == (uint)(~TestData_LHS[i].x6) &
x.x7 == (uint)(~TestData_LHS[i].x7);
}
Assert.AreEqual(true, result);
}
public static void Divide()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
uint8 x = TestData_LHS[i] / TestData_RHS[i];
result &= x.x0 == (uint)(TestData_LHS[i].x0 / TestData_RHS[i].x0) &
x.x1 == (uint)(TestData_LHS[i].x1 / TestData_RHS[i].x1) &
x.x2 == (uint)(TestData_LHS[i].x2 / TestData_RHS[i].x2) &
x.x3 == (uint)(TestData_LHS[i].x3 / TestData_RHS[i].x3) &
x.x4 == (uint)(TestData_LHS[i].x4 / TestData_RHS[i].x4) &
x.x5 == (uint)(TestData_LHS[i].x5 / TestData_RHS[i].x5) &
x.x6 == (uint)(TestData_LHS[i].x6 / TestData_RHS[i].x6) &
x.x7 == (uint)(TestData_LHS[i].x7 / TestData_RHS[i].x7);
}
Assert.AreEqual(true, result);
}
public static void Add()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
uint8 x = TestData_LHS[i] + TestData_RHS[i];
result &= x.x0 == (uint)(TestData_LHS[i].x0 + TestData_RHS[i].x0) &
x.x1 == (uint)(TestData_LHS[i].x1 + TestData_RHS[i].x1) &
x.x2 == (uint)(TestData_LHS[i].x2 + TestData_RHS[i].x2) &
x.x3 == (uint)(TestData_LHS[i].x3 + TestData_RHS[i].x3) &
x.x4 == (uint)(TestData_LHS[i].x4 + TestData_RHS[i].x4) &
x.x5 == (uint)(TestData_LHS[i].x5 + TestData_RHS[i].x5) &
x.x6 == (uint)(TestData_LHS[i].x6 + TestData_RHS[i].x6) &
x.x7 == (uint)(TestData_LHS[i].x7 + TestData_RHS[i].x7);
}
Assert.AreEqual(true, result);
}
private void AssignFromOther(GGUUID other)
{
// No unions. No marshalling. Assign each manually...
Data0 = other.Data0;
Data1 = other.Data1;
Data2 = other.Data2;
Data3 = other.Data3;
Data4 = other.Data4;
Data5 = other.Data5;
Data6 = other.Data6;
Data7 = other.Data7;
Data8 = other.Data8;
Data9 = other.Data9;
Data10 = other.Data10;
Data11 = other.Data11;
Data12 = other.Data12;
Data13 = other.Data13;
Data14 = other.Data14;
Data15 = other.Data15;
}
// 构建握手需要的包
private byte[] packetBuild(uint8 challengeTimes)
{
// 四部分组成 packet(20B) = begin(1B) + times(1B) + rand(2B) + end(17B)
byte[] begin = new byte[] { 0x01 };
byte[] rand = new byte[2];
randomBuilder.NextBytes(rand);
byte[] times = { challengeTimes };
byte[] end = new byte[] { 0x6a,
0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00 };
//连接
byte[] packet = begin.Concat(rand).Concat(times).Concat(end).ToArray();
//确保长度为20
Debug.Assert(packet.Length == 20, $"Incorrect Packet Length: {packet.Length}");
return(packet);
}
public static void XOR()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
uint8 x = TestData_LHS[i] ^ TestData_RHS[i];
result &= x.x0 == (uint)(TestData_LHS[i].x0 ^ TestData_RHS[i].x0) &
x.x1 == (uint)(TestData_LHS[i].x1 ^ TestData_RHS[i].x1) &
x.x2 == (uint)(TestData_LHS[i].x2 ^ TestData_RHS[i].x2) &
x.x3 == (uint)(TestData_LHS[i].x3 ^ TestData_RHS[i].x3) &
x.x4 == (uint)(TestData_LHS[i].x4 ^ TestData_RHS[i].x4) &
x.x5 == (uint)(TestData_LHS[i].x5 ^ TestData_RHS[i].x5) &
x.x6 == (uint)(TestData_LHS[i].x6 ^ TestData_RHS[i].x6) &
x.x7 == (uint)(TestData_LHS[i].x7 ^ TestData_RHS[i].x7);
}
Assert.AreEqual(true, result);
}
public static void OR()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
uint8 x = TestData_LHS[i] | TestData_RHS[i];
result &= x.x0 == (uint)(TestData_LHS[i].x0 | TestData_RHS[i].x0) &
x.x1 == (uint)(TestData_LHS[i].x1 | TestData_RHS[i].x1) &
x.x2 == (uint)(TestData_LHS[i].x2 | TestData_RHS[i].x2) &
x.x3 == (uint)(TestData_LHS[i].x3 | TestData_RHS[i].x3) &
x.x4 == (uint)(TestData_LHS[i].x4 | TestData_RHS[i].x4) &
x.x5 == (uint)(TestData_LHS[i].x5 | TestData_RHS[i].x5) &
x.x6 == (uint)(TestData_LHS[i].x6 | TestData_RHS[i].x6) &
x.x7 == (uint)(TestData_LHS[i].x7 | TestData_RHS[i].x7);
}
Assert.AreEqual(true, result);
}
public static void AND()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
uint8 x = TestData_LHS[i] & TestData_RHS[i];
result &= x.x0 == (uint)(TestData_LHS[i].x0 & TestData_RHS[i].x0) &
x.x1 == (uint)(TestData_LHS[i].x1 & TestData_RHS[i].x1) &
x.x2 == (uint)(TestData_LHS[i].x2 & TestData_RHS[i].x2) &
x.x3 == (uint)(TestData_LHS[i].x3 & TestData_RHS[i].x3) &
x.x4 == (uint)(TestData_LHS[i].x4 & TestData_RHS[i].x4) &
x.x5 == (uint)(TestData_LHS[i].x5 & TestData_RHS[i].x5) &
x.x6 == (uint)(TestData_LHS[i].x6 & TestData_RHS[i].x6) &
x.x7 == (uint)(TestData_LHS[i].x7 & TestData_RHS[i].x7);
}
Assert.AreEqual(true, result);
}
public static void Remainder()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
uint8 x = TestData_LHS[i] % TestData_RHS[i];
result &= x.x0 == (uint)(TestData_LHS[i].x0 % TestData_RHS[i].x0) &
x.x1 == (uint)(TestData_LHS[i].x1 % TestData_RHS[i].x1) &
x.x2 == (uint)(TestData_LHS[i].x2 % TestData_RHS[i].x2) &
x.x3 == (uint)(TestData_LHS[i].x3 % TestData_RHS[i].x3) &
x.x4 == (uint)(TestData_LHS[i].x4 % TestData_RHS[i].x4) &
x.x5 == (uint)(TestData_LHS[i].x5 % TestData_RHS[i].x5) &
x.x6 == (uint)(TestData_LHS[i].x6 % TestData_RHS[i].x6) &
x.x7 == (uint)(TestData_LHS[i].x7 % TestData_RHS[i].x7);
}
Assert.AreEqual(true, result);
}
template <typename T> void ilToOgreInternal(uint8 *tar, PixelFormat ogrefmt,
T r, T g, T b, T a)
{
const int ilfmt = ilGetInteger( IL_IMAGE_FORMAT );
T *src = (T*)ilGetData();
T *srcend = (T*)((uint8*)ilGetData() + ilGetInteger( IL_IMAGE_SIZE_OF_DATA ));
const size_t elemSize = PixelUtil::getNumElemBytes(ogrefmt);
while(src < srcend) {
switch(ilfmt) {
case IL_RGB:
r = src[0]; g = src[1]; b = src[2];
src += 3;
break;
case IL_BGR:
b = src[0]; g = src[1]; r = src[2];
src += 3;
break;
case IL_LUMINANCE:
r = src[0]; g = src[0]; b = src[0];
src += 1;
break;
case IL_LUMINANCE_ALPHA:
r = src[0]; g = src[0]; b = src[0]; a = src[1];
src += 2;
break;
case IL_RGBA:
r = src[0]; g = src[1]; b = src[2]; a = src[3];
src += 4;
break;
case IL_BGRA:
b = src[0]; g = src[1]; r = src[2]; a = src[3];
src += 4;
break;
default:
return;
}
packI(r, g, b, a, ogrefmt, tar);
tar += elemSize;
}
}
public static void ror_uint8()
{
bool result = true;
for (int i = 0; i < UInt8.NUM_TESTS; i++)
{
for (int j = 0; j < NUM_ROTATION_TESTS; j++)
{
uint8 test = maxmath.ror(UInt8.TestData_LHS[i], UInt8.TestData_RHS[i]);
result &= test.x0 == math.ror(UInt8.TestData_LHS[i].x0, (int)UInt8.TestData_RHS[i].x0);
result &= test.x1 == math.ror(UInt8.TestData_LHS[i].x1, (int)UInt8.TestData_RHS[i].x1);
result &= test.x2 == math.ror(UInt8.TestData_LHS[i].x2, (int)UInt8.TestData_RHS[i].x2);
result &= test.x3 == math.ror(UInt8.TestData_LHS[i].x3, (int)UInt8.TestData_RHS[i].x3);
result &= test.x4 == math.ror(UInt8.TestData_LHS[i].x4, (int)UInt8.TestData_RHS[i].x4);
result &= test.x5 == math.ror(UInt8.TestData_LHS[i].x5, (int)UInt8.TestData_RHS[i].x5);
result &= test.x6 == math.ror(UInt8.TestData_LHS[i].x6, (int)UInt8.TestData_RHS[i].x6);
result &= test.x7 == math.ror(UInt8.TestData_LHS[i].x7, (int)UInt8.TestData_RHS[i].x7);
}
}
Assert.AreEqual(true, result);
}
public static void ShiftRight()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
for (int j = 0; j < 32; j++)
{
uint8 x = TestData_LHS[i] >> j;
result &= x.x0 == (uint)(TestData_LHS[i].x0 >> j) &
x.x1 == (uint)(TestData_LHS[i].x1 >> j) &
x.x2 == (uint)(TestData_LHS[i].x2 >> j) &
x.x3 == (uint)(TestData_LHS[i].x3 >> j) &
x.x4 == (uint)(TestData_LHS[i].x4 >> j) &
x.x5 == (uint)(TestData_LHS[i].x5 >> j) &
x.x6 == (uint)(TestData_LHS[i].x6 >> j) &
x.x7 == (uint)(TestData_LHS[i].x7 >> j);
}
}
Assert.AreEqual(true, result);
}
public static void ShiftLeft()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
for (int j = 0; j < 32; j++)
{
uint8 x = TestData_LHS[i] << j;
result &= x.x0 == (uint)(TestData_LHS[i].x0 << j) &
x.x1 == (uint)(TestData_LHS[i].x1 << j) &
x.x2 == (uint)(TestData_LHS[i].x2 << j) &
x.x3 == (uint)(TestData_LHS[i].x3 << j) &
x.x4 == (uint)(TestData_LHS[i].x4 << j) &
x.x5 == (uint)(TestData_LHS[i].x5 << j) &
x.x6 == (uint)(TestData_LHS[i].x6 << j) &
x.x7 == (uint)(TestData_LHS[i].x7 << j);
}
}
Assert.AreEqual(true, result);
}
public static void LoadTextureInternal(Flood.GUI.Texture t, uint8* data, int size)
{
ImageHandle iHandle = ImageCreate(AllocatorGetHeap(),t.Width,t.Height, PixelFormat.B8G8R8A8);
//array to vector
std.vector<byte> buffer(size);
std.copy(data, data+size, buffer.begin());
iHandle.Resolve().setBuffer(buffer);
t.RendererData = iHandle.getId();
iHandle.addReference(); //hackzito
}
//-----------------------------------------------------------------------
/// Helper functions for DevIL to Ogre conversion
inline void packI(uint8 r, uint8 g, uint8 b, uint8 a, PixelFormat pf, void *dest)
{
PixelUtil::packColour(r, g, b, a, pf, dest);
}
//-----------------------------------------------------------------------
/// Helper functions for DevIL to Ogre conversion
inline void packI(uint8 r, uint8 g, uint8 b, uint8 a, PixelFormat pf, void* dest)
{
PixelUtil::packColour(r, g, b, a, pf, dest);
}
public static void ShuffleSetter()
{
bool result = true;
for (uint i = 0; i < NUM_TESTS; i++)
{
uint8 v4_0 = TestData_LHS[i];
v4_0.v4_0 = UInt4.TestData_LHS[i];
result &= v4_0.x0 == UInt4.TestData_LHS[i].x;
result &= v4_0.x1 == UInt4.TestData_LHS[i].y;
result &= v4_0.x2 == UInt4.TestData_LHS[i].z;
result &= v4_0.x3 == UInt4.TestData_LHS[i].w;
result &= v4_0.x4 == TestData_LHS[i].x4;
result &= v4_0.x5 == TestData_LHS[i].x5;
result &= v4_0.x6 == TestData_LHS[i].x6;
result &= v4_0.x7 == TestData_LHS[i].x7;
uint8 v4_1 = TestData_LHS[i];
v4_1.v4_1 = UInt4.TestData_LHS[i];
result &= v4_1.x0 == TestData_LHS[i].x0;
result &= v4_1.x1 == UInt4.TestData_LHS[i].x;
result &= v4_1.x2 == UInt4.TestData_LHS[i].y;
result &= v4_1.x3 == UInt4.TestData_LHS[i].z;
result &= v4_1.x4 == UInt4.TestData_LHS[i].w;
result &= v4_1.x5 == TestData_LHS[i].x5;
result &= v4_1.x6 == TestData_LHS[i].x6;
result &= v4_1.x7 == TestData_LHS[i].x7;
uint8 v4_2 = TestData_LHS[i];
v4_2.v4_2 = UInt4.TestData_LHS[i];
result &= v4_2.x0 == TestData_LHS[i].x0;
result &= v4_2.x1 == TestData_LHS[i].x1;
result &= v4_2.x2 == UInt4.TestData_LHS[i].x;
result &= v4_2.x3 == UInt4.TestData_LHS[i].y;
result &= v4_2.x4 == UInt4.TestData_LHS[i].z;
result &= v4_2.x5 == UInt4.TestData_LHS[i].w;
result &= v4_2.x6 == TestData_LHS[i].x6;
result &= v4_2.x7 == TestData_LHS[i].x7;
uint8 v4_3 = TestData_LHS[i];
v4_3.v4_3 = UInt4.TestData_LHS[i];
result &= v4_3.x0 == TestData_LHS[i].x0;
result &= v4_3.x1 == TestData_LHS[i].x1;
result &= v4_3.x2 == TestData_LHS[i].x2;
result &= v4_3.x3 == UInt4.TestData_LHS[i].x;
result &= v4_3.x4 == UInt4.TestData_LHS[i].y;
result &= v4_3.x5 == UInt4.TestData_LHS[i].z;
result &= v4_3.x6 == UInt4.TestData_LHS[i].w;
result &= v4_3.x7 == TestData_LHS[i].x7;
uint8 v4_4 = TestData_LHS[i];
v4_4.v4_4 = UInt4.TestData_LHS[i];
result &= v4_4.x0 == TestData_LHS[i].x0;
result &= v4_4.x1 == TestData_LHS[i].x1;
result &= v4_4.x2 == TestData_LHS[i].x2;
result &= v4_4.x3 == TestData_LHS[i].x3;
result &= v4_4.x4 == UInt4.TestData_LHS[i].x;
result &= v4_4.x5 == UInt4.TestData_LHS[i].y;
result &= v4_4.x6 == UInt4.TestData_LHS[i].z;
result &= v4_4.x7 == UInt4.TestData_LHS[i].w;
uint8 v3_0 = TestData_LHS[i];
v3_0.v3_0 = UInt3.TestData_LHS[i];
result &= v3_0.x0 == UInt3.TestData_LHS[i].x;
result &= v3_0.x1 == UInt3.TestData_LHS[i].y;
result &= v3_0.x2 == UInt3.TestData_LHS[i].z;
result &= v3_0.x3 == TestData_LHS[i].x3;
result &= v3_0.x4 == TestData_LHS[i].x4;
result &= v3_0.x5 == TestData_LHS[i].x5;
result &= v3_0.x6 == TestData_LHS[i].x6;
result &= v3_0.x7 == TestData_LHS[i].x7;
uint8 v3_1 = TestData_LHS[i];
v3_1.v3_1 = UInt3.TestData_LHS[i];
result &= v3_1.x0 == TestData_LHS[i].x0;
result &= v3_1.x1 == UInt3.TestData_LHS[i].x;
result &= v3_1.x2 == UInt3.TestData_LHS[i].y;
result &= v3_1.x3 == UInt3.TestData_LHS[i].z;
result &= v3_1.x4 == TestData_LHS[i].x4;
result &= v3_1.x5 == TestData_LHS[i].x5;
result &= v3_1.x6 == TestData_LHS[i].x6;
result &= v3_1.x7 == TestData_LHS[i].x7;
uint8 v3_2 = TestData_LHS[i];
v3_2.v3_2 = UInt3.TestData_LHS[i];
result &= v3_2.x0 == TestData_LHS[i].x0;
result &= v3_2.x1 == TestData_LHS[i].x1;
result &= v3_2.x2 == UInt3.TestData_LHS[i].x;
result &= v3_2.x3 == UInt3.TestData_LHS[i].y;
result &= v3_2.x4 == UInt3.TestData_LHS[i].z;
result &= v3_2.x5 == TestData_LHS[i].x5;
result &= v3_2.x6 == TestData_LHS[i].x6;
result &= v3_2.x7 == TestData_LHS[i].x7;
uint8 v3_3 = TestData_LHS[i];
v3_3.v3_3 = UInt3.TestData_LHS[i];
result &= v3_3.x0 == TestData_LHS[i].x0;
result &= v3_3.x1 == TestData_LHS[i].x1;
result &= v3_3.x2 == TestData_LHS[i].x2;
result &= v3_3.x3 == UInt3.TestData_LHS[i].x;
result &= v3_3.x4 == UInt3.TestData_LHS[i].y;
result &= v3_3.x5 == UInt3.TestData_LHS[i].z;
result &= v3_3.x6 == TestData_LHS[i].x6;
result &= v3_3.x7 == TestData_LHS[i].x7;
uint8 v3_4 = TestData_LHS[i];
v3_4.v3_4 = UInt3.TestData_LHS[i];
result &= v3_4.x0 == TestData_LHS[i].x0;
result &= v3_4.x1 == TestData_LHS[i].x1;
result &= v3_4.x2 == TestData_LHS[i].x2;
result &= v3_4.x3 == TestData_LHS[i].x3;
result &= v3_4.x4 == UInt3.TestData_LHS[i].x;
result &= v3_4.x5 == UInt3.TestData_LHS[i].y;
result &= v3_4.x6 == UInt3.TestData_LHS[i].z;
result &= v3_4.x7 == TestData_LHS[i].x7;
uint8 v3_5 = TestData_LHS[i];
v3_5.v3_5 = UInt3.TestData_LHS[i];
result &= v3_5.x0 == TestData_LHS[i].x0;
result &= v3_5.x1 == TestData_LHS[i].x1;
result &= v3_5.x2 == TestData_LHS[i].x2;
result &= v3_5.x3 == TestData_LHS[i].x3;
result &= v3_5.x4 == TestData_LHS[i].x4;
result &= v3_5.x5 == UInt3.TestData_LHS[i].x;
result &= v3_5.x6 == UInt3.TestData_LHS[i].y;
result &= v3_5.x7 == UInt3.TestData_LHS[i].z;
uint8 v2_0 = TestData_LHS[i];
v2_0.v2_0 = UInt2.TestData_LHS[i];
result &= v2_0.x0 == UInt2.TestData_LHS[i].x;
result &= v2_0.x1 == UInt2.TestData_LHS[i].y;
result &= v2_0.x2 == TestData_LHS[i].x2;
result &= v2_0.x3 == TestData_LHS[i].x3;
result &= v2_0.x4 == TestData_LHS[i].x4;
result &= v2_0.x5 == TestData_LHS[i].x5;
result &= v2_0.x6 == TestData_LHS[i].x6;
result &= v2_0.x7 == TestData_LHS[i].x7;
uint8 v2_1 = TestData_LHS[i];
v2_1.v2_1 = UInt2.TestData_LHS[i];
result &= v2_1.x0 == TestData_LHS[i].x0;
result &= v2_1.x1 == UInt2.TestData_LHS[i].x;
result &= v2_1.x2 == UInt2.TestData_LHS[i].y;
result &= v2_1.x3 == TestData_LHS[i].x3;
result &= v2_1.x4 == TestData_LHS[i].x4;
result &= v2_1.x5 == TestData_LHS[i].x5;
result &= v2_1.x6 == TestData_LHS[i].x6;
result &= v2_1.x7 == TestData_LHS[i].x7;
uint8 v2_2 = TestData_LHS[i];
v2_2.v2_2 = UInt2.TestData_LHS[i];
result &= v2_2.x0 == TestData_LHS[i].x0;
result &= v2_2.x1 == TestData_LHS[i].x1;
result &= v2_2.x2 == UInt2.TestData_LHS[i].x;
result &= v2_2.x3 == UInt2.TestData_LHS[i].y;
result &= v2_2.x4 == TestData_LHS[i].x4;
result &= v2_2.x5 == TestData_LHS[i].x5;
result &= v2_2.x6 == TestData_LHS[i].x6;
result &= v2_2.x7 == TestData_LHS[i].x7;
uint8 v2_3 = TestData_LHS[i];
v2_3.v2_3 = UInt2.TestData_LHS[i];
result &= v2_3.x0 == TestData_LHS[i].x0;
result &= v2_3.x1 == TestData_LHS[i].x1;
result &= v2_3.x2 == TestData_LHS[i].x2;
result &= v2_3.x3 == UInt2.TestData_LHS[i].x;
result &= v2_3.x4 == UInt2.TestData_LHS[i].y;
result &= v2_3.x5 == TestData_LHS[i].x5;
result &= v2_3.x6 == TestData_LHS[i].x6;
result &= v2_3.x7 == TestData_LHS[i].x7;
uint8 v2_4 = TestData_LHS[i];
v2_4.v2_4 = UInt2.TestData_LHS[i];
result &= v2_4.x0 == TestData_LHS[i].x0;
result &= v2_4.x1 == TestData_LHS[i].x1;
result &= v2_4.x2 == TestData_LHS[i].x2;
result &= v2_4.x3 == TestData_LHS[i].x3;
result &= v2_4.x4 == UInt2.TestData_LHS[i].x;
result &= v2_4.x5 == UInt2.TestData_LHS[i].y;
result &= v2_4.x6 == TestData_LHS[i].x6;
result &= v2_4.x7 == TestData_LHS[i].x7;
uint8 v2_5 = TestData_LHS[i];
v2_5.v2_5 = UInt2.TestData_LHS[i];
result &= v2_5.x0 == TestData_LHS[i].x0;
result &= v2_5.x1 == TestData_LHS[i].x1;
result &= v2_5.x2 == TestData_LHS[i].x2;
result &= v2_5.x3 == TestData_LHS[i].x3;
result &= v2_5.x4 == TestData_LHS[i].x4;
result &= v2_5.x5 == UInt2.TestData_LHS[i].x;
result &= v2_5.x6 == UInt2.TestData_LHS[i].y;
result &= v2_5.x7 == TestData_LHS[i].x7;
uint8 v2_6 = TestData_LHS[i];
v2_6.v2_6 = UInt2.TestData_LHS[i];
result &= v2_6.x0 == TestData_LHS[i].x0;
result &= v2_6.x1 == TestData_LHS[i].x1;
result &= v2_6.x2 == TestData_LHS[i].x2;
result &= v2_6.x3 == TestData_LHS[i].x3;
result &= v2_6.x4 == TestData_LHS[i].x4;
result &= v2_6.x5 == TestData_LHS[i].x5;
result &= v2_6.x6 == UInt2.TestData_LHS[i].x;
result &= v2_6.x7 == UInt2.TestData_LHS[i].y;
}
Assert.AreEqual(true, result);
}
