private void RunTest(TestVector test)
{
var seed = TestUtils.ParseHex(test.strHexMaster);
var key = new ExtKey(seed);
var pubkey = key.Neuter();
foreach (var derive in test.vDerive)
{
var data = key.ToBytes();
Assert.Equal(74, data.Length);
data = pubkey.ToBytes();
Assert.Equal(74, data.Length);
// Test private key
var b58key = Network.Main.CreateBitcoinExtKey(key);
Assert.True(b58key.ToString() == derive.prv);
// Test public key
var b58pubkey = Network.Main.CreateBitcoinExtPubKey(pubkey);
Assert.True(b58pubkey.ToString() == derive.pub);
// Derive new keys
var keyNew = key.Derive(derive.nChild);
var pubkeyNew = keyNew.Neuter();
if (!((derive.nChild & 0x80000000) != 0))
{
// Compare with public derivation
var pubkeyNew2 = pubkey.Derive(derive.nChild);
Assert.True(pubkeyNew == pubkeyNew2);
}
key = keyNew;
pubkey = pubkeyNew;
}
}
private static void ParsingSuccess(TestVector test)
{
var parser = new Parser();
var ast = parser.ParseScript(test.Program);
Helpers.CompareObjects(test.Script, ast);
}
public void BaseConverter_CommonBase32HexTest()
{
var converter = BaseConvert.Base32Hex;
// See https://tools.ietf.org/html/rfc4648#page-12
var a = new[] {
TestVector.Create(Encoding.ASCII.GetBytes(""), ""),
TestVector.Create(Encoding.ASCII.GetBytes("f"), "CO======"),
TestVector.Create(Encoding.ASCII.GetBytes("fo"), "CPNG===="),
TestVector.Create(Encoding.ASCII.GetBytes("foo"), "CPNMU==="),
TestVector.Create(Encoding.ASCII.GetBytes("foob"), "CPNMUOG="),
TestVector.Create(Encoding.ASCII.GetBytes("fooba"), "CPNMUOJ1"),
TestVector.Create(Encoding.ASCII.GetBytes("foobar"), "CPNMUOJ1E8======"),
};
var q = new[] {
TestBuilder
.NewTestVectorTest(a, converter, converter.Encode)
.Create(),
};
foreach (var test in q)
{
test();
}
}
public void CanSubtractTwoVectors(TestVector testVectorA, TestVector testVectorB)
{
Vector <T> a = Get(testVectorA);
Vector <T> b = Get(testVectorB);
Assume.That(a.Count, Is.EqualTo(b.Count));
var hasha = a.GetHashCode();
var hashb = b.GetHashCode();
var result1 = a - b;
var result2 = a.Subtract(b);
var result3 = a.Clone();
result3.Subtract(b, result3);
Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
Assert.That(result1, Is.Not.SameAs(a));
Assert.That(result1, Is.Not.SameAs(b));
Assert.That(result2, Is.Not.SameAs(a));
Assert.That(result2, Is.Not.SameAs(b));
Assert.That(result3, Is.Not.SameAs(a));
Assert.That(result3, Is.Not.SameAs(b));
Assert.That(result1.Equals(result2));
Assert.That(result1.Equals(result3));
for (var i = 0; i < Math.Min(a.Count, 20); i++)
{
Assert.That(result1[i], Is.EqualTo(Operator.Subtract(a[i], b[i])));
Assert.That(result2[i], Is.EqualTo(Operator.Subtract(a[i], b[i])));
Assert.That(result3[i], Is.EqualTo(Operator.Subtract(a[i], b[i])));
}
}
private void RunTest(TestVector test)
{
PrivateKeychain key = new PrivateKeychain(test.strHexMaster);
PublicKeychain pubkey = key.GetPublicKeychain();
foreach (TestDerivation derive in test.vDerive)
{
byte[] data = key.ToBytes();
Assert.Equal(74, data.Length);
data = pubkey.ToBytes();
Assert.Equal(74, data.Length);
// Test private key
var b58key = key.ToString();
Assert.Equal(b58key, derive.prv);
// Test public key
var b58pubkey = pubkey.ToString();
Assert.Equal(b58pubkey, derive.pub);
// Derive new keys
PrivateKeychain keyNew = key.Derive(derive.nChild);
PublicKeychain pubkeyNew = keyNew.GetPublicKeychain();
if (!((derive.nChild & 0x80000000) != 0))
{
// Compare with public derivation
PublicKeychain pubkeyNew2 = pubkey.Derive(derive.nChild);
Assert.Equal(pubkeyNew.ToHex(), pubkeyNew2.ToHex());
}
key = keyNew;
pubkey = pubkeyNew;
}
}
private void RunTestVector(TestVector v)
{
int bits = v.Bits;
int partialBits = bits % 8;
//Console.WriteLine(v.Algorithm + " " + bits + "-bit");
//Console.WriteLine(Hex.ToHexString(v.Message).ToUpper());
//Console.WriteLine(Hex.ToHexString(v.Hash).ToUpper());
MySha3Digest d = CreateDigest(v.Algorithm);
byte[] output = new byte[d.GetDigestSize()];
byte[] m = v.Message;
if (partialBits == 0)
{
d.BlockUpdate(m, 0, m.Length);
d.DoFinal(output, 0);
}
else
{
d.BlockUpdate(m, 0, m.Length - 1);
d.MyDoFinal(output, 0, m[m.Length - 1], partialBits);
}
if (!Arrays.AreEqual(v.Hash, output))
{
Fail(v.Algorithm + " " + v.Bits + "-bit test vector hash mismatch");
//Console.Error.WriteLine(v.Algorithm + " " + v.Bits + "-bit test vector hash mismatch");
//Console.Error.WriteLine(Hex.ToHexString(output).ToUpper());
}
}
private void RunTest(TestVector test)
{
var seed = TestUtils.ParseHex(test.strHexMaster);
ExtKey key = new ExtKey(seed);
ExtPubKey pubkey = key.Neuter();
foreach(TestDerivation derive in test.vDerive)
{
byte[] data = key.ToBytes();
Assert.Equal(74, data.Length);
data = pubkey.ToBytes();
Assert.Equal(74, data.Length);
// Test private key
BitcoinExtKey b58key = Network.Main.CreateBitcoinExtKey(key);
Assert.True(b58key.ToString() == derive.prv);
// Test public key
BitcoinExtPubKey b58pubkey = Network.Main.CreateBitcoinExtPubKey(pubkey);
Assert.True(b58pubkey.ToString() == derive.pub);
// Derive new keys
ExtKey keyNew = key.Derive(derive.nChild);
ExtPubKey pubkeyNew = keyNew.Neuter();
if(!((derive.nChild & 0x80000000) != 0))
{
// Compare with public derivation
ExtPubKey pubkeyNew2 = pubkey.Derive(derive.nChild);
Assert.True(pubkeyNew == pubkeyNew2);
}
key = keyNew;
pubkey = pubkeyNew;
}
}
public void BaseConverter_CommonBase32Test()
{
var converter = BaseConvert.Base32;
// See https://tools.ietf.org/html/rfc4648#page-12
var a = new[] {
TestVector.Create(Encoding.ASCII.GetBytes(""), ""),
TestVector.Create(Encoding.ASCII.GetBytes("f"), "MY======"),
TestVector.Create(Encoding.ASCII.GetBytes("fo"), "MZXQ===="),
TestVector.Create(Encoding.ASCII.GetBytes("foo"), "MZXW6==="),
TestVector.Create(Encoding.ASCII.GetBytes("foob"), "MZXW6YQ="),
TestVector.Create(Encoding.ASCII.GetBytes("fooba"), "MZXW6YTB"),
TestVector.Create(Encoding.ASCII.GetBytes("foobar"), "MZXW6YTBOI======"),
};
var q = new[] {
TestBuilder
.NewTestVectorTest(a, converter, converter.Encode)
.Create(),
};
foreach (var test in q)
{
test();
}
}
public void BaseConverter_CommonHexadecimalTest()
{
var converter = BaseConvert.Hexadecimal;
// See https://tools.ietf.org/html/rfc4648#page-12
var a = new[] {
TestVector.Create(Encoding.ASCII.GetBytes(""), ""),
TestVector.Create(Encoding.ASCII.GetBytes("f"), "66"),
TestVector.Create(Encoding.ASCII.GetBytes("fo"), "666F"),
TestVector.Create(Encoding.ASCII.GetBytes("foo"), "666F6F"),
TestVector.Create(Encoding.ASCII.GetBytes("foob"), "666F6F62"),
TestVector.Create(Encoding.ASCII.GetBytes("fooba"), "666F6F6261"),
TestVector.Create(Encoding.ASCII.GetBytes("foobar"), "666F6F626172"),
};
var q = new[] {
TestBuilder
.NewTestVectorTest(a, converter, converter.Encode)
.Create(),
};
foreach (var test in q)
{
test();
}
}
private void RunTest(TestVector test)
{
var seed = TestUtils.ParseHex(test.strHexMaster);
ExtKey key = new ExtKey(seed);
ExtPubKey pubkey = key.Neuter();
foreach (TestDerivation derive in test.vDerive)
{
byte[] data = key.ToBytes();
Assert.Equal(74, data.Length);
data = pubkey.ToBytes();
Assert.Equal(74, data.Length);
// Test private key
BitcoinExtKey b58key = Network.Main.CreateBitcoinExtKey(key);
var a = Encoders.Hex.EncodeData(Encoders.Base58Check.DecodeData(b58key.ToString()));
var expected = Encoders.Hex.EncodeData(Encoders.Base58Check.DecodeData(derive.prv));
Assert.True(b58key.ToString() == derive.prv);
// Test public key
BitcoinExtPubKey b58pubkey = Network.Main.CreateBitcoinExtPubKey(pubkey);
Assert.True(b58pubkey.ToString() == derive.pub);
// Derive new keys
ExtKey keyNew = key.Derive(derive.nChild);
ExtPubKey pubkeyNew = keyNew.Neuter();
if (!((derive.nChild & 0x80000000) != 0))
{
// Compare with public derivation
ExtPubKey pubkeyNew2 = pubkey.Derive(derive.nChild);
Assert.True(pubkeyNew == pubkeyNew2);
}
key = keyNew;
pubkey = pubkeyNew;
}
}
public void BaseConverter_CommonBase64Test()
{
var converter = BaseConvert.Base64;
// See https://tools.ietf.org/html/rfc4648#page-12
var a = new[] {
TestVector.Create(Encoding.ASCII.GetBytes(""), ""),
TestVector.Create(Encoding.ASCII.GetBytes("f"), "Zg=="),
TestVector.Create(Encoding.ASCII.GetBytes("fo"), "Zm8="),
TestVector.Create(Encoding.ASCII.GetBytes("foo"), "Zm9v"),
TestVector.Create(Encoding.ASCII.GetBytes("foob"), "Zm9vYg=="),
TestVector.Create(Encoding.ASCII.GetBytes("fooba"), "Zm9vYmE="),
TestVector.Create(Encoding.ASCII.GetBytes("foobar"), "Zm9vYmFy"),
};
var q = new[] {
TestBuilder
.NewTestVectorTest(a, converter, converter.Encode)
.Create(),
};
foreach (var test in q)
{
test();
}
}
public void CRCTestMethod()
{
var pluginInstance = TestHelpers.GetPluginInstance("CRC");
var scenario1 = new PluginTestScenario(pluginInstance, new[] { "InputStream", ".Width", ".Polynomial", ".Init", ".XorOut", ".RefIn", ".RefOut" }, new[] { "OutputStream" });
var scenario2 = new PluginTestScenario(pluginInstance, new[] { "InputStream", ".CRCMethod" }, new[] { "OutputStream" });
object[] output;
var input = "313233343536373839".HexToStream(); // "123456789" as Stream
ulong check;
for (int method = 0; method < testvectors.Length; method++)
{
TestVector vector = testvectors[method];
// set CRC parameters individually
output = scenario1.GetOutputs(new object[] { input, vector.width, vector.polynomial.ToString("x"), vector.init.ToString("x"), vector.xorout.ToString("x"), vector.refin, vector.refout });
check = stream2ulong(output[0] as ICryptoolStream);
Assert.AreEqual(vector.check.ToString("x"), check.ToString("x"), "Unexpected value in test '" + vector.name + "'.");
// set CRC parameters by selecting a CRCMethod
output = scenario2.GetOutputs(new object[] { input, method });
check = stream2ulong(output[0] as ICryptoolStream);
Assert.AreEqual(vector.check.ToString("x"), check.ToString("x"), "Unexpected value in test '" + vector.name + "'.");
}
}
internal void CompileSuccess(TestVector test)
{
var compiler = new Compiler();
var program = compiler.CompileScript(test.Script);
var diceRoller = new DiceRoller(1000, new Random(0));
var result = program(diceRoller);
Helpers.CompareObjects(test.Results, result);
}
private void ValidateConversion <T>(TestVector vector, BitcoinAddress address) where T : BitcoinAddress
{
Assert.NotNull(address);
var key = address as T;
// Perform some validations
Assert.NotNull(key);
Assert.Equal(vector.Type, GetAddressType(key));
Assert.Equal(CashFormat.Legacy, GetAddressFormat(key));
Assert.Equal(vector.Legacy, key.ToString());
// Convert to CashAddr format
var cashAddrKey = ConvertAddressToCashAddr(key);
// And perform some validations
Assert.NotNull(cashAddrKey);
Assert.Equal(vector.Type, GetAddressType(cashAddrKey));
Assert.Equal(CashFormat.Cashaddr, GetAddressFormat(cashAddrKey));
Assert.Equal(vector.CashAddr, cashAddrKey.ToString());
// Convert back to legacy and validate it
var legacyAddrKey = ConvertAddressToLegacy(cashAddrKey);
Assert.NotNull(legacyAddrKey);
Assert.Equal(vector.Type, GetAddressType(legacyAddrKey));
Assert.Equal(CashFormat.Legacy, GetAddressFormat(legacyAddrKey));
Assert.Equal(vector.Legacy, legacyAddrKey.ToString());
// Raw mode validation
var legacyHashBytes = GetHashBytes(legacyAddrKey);
var legacyHashString = Encoders.Hex.EncodeData(legacyHashBytes);
Assert.Equal(vector.Hash, legacyHashString);
var cashAddrHashBytes = GetHashBytes(cashAddrKey);
var cashAddrHashString = Encoders.Hex.EncodeData(cashAddrHashBytes);
Assert.Equal(vector.Hash, cashAddrHashString);
// Try to recreate addresses with hashes
switch (address)
{
case BitcoinPubKeyAddress pubKey:
var pubKey2 = new BitcoinPubKeyAddress(pubKey.Hash, pubKey.Network);
Assert.Equal(vector.CashAddr, pubKey2.ToString());
break;
case BitcoinScriptAddress scriptKey:
var scriptKey2 = new BitcoinScriptAddress(scriptKey.Hash, scriptKey.Network);
Assert.Equal(vector.CashAddr, scriptKey2.ToString());
break;
default:
throw new InvalidOperationException();
}
}
private static void RunSuccess(TestVector test)
{
var builder = new Builder(new Limitations {
MaxRollNbr = 1000, MaxProgramSize = 1000
});
builder.Random = new Random(0);
var result = builder.BuildScript(test.Program)();
Helpers.CompareObjects(test.Results, result);
}
public void BaseConverter_CommonDecimalTest()
{
var converter = BaseConvert.Decimal;
var a = new[] {
TestVector.Create(int.MinValue, "0000000000"),
TestVector.Create(-1, "2147483647"),
TestVector.Create(0, "2147483648"),
TestVector.Create(+1, "2147483649"),
TestVector.Create(int.MaxValue, "4294967295"),
};
var b = new[] {
TestVector.Create(0U, "0000000000"),
TestVector.Create(1U, "0000000001"),
TestVector.Create(uint.MaxValue / 2 + 1, "2147483648"),
TestVector.Create(uint.MaxValue, "4294967295"),
};
var c = new[] {
TestVector.Create(long.MinValue, "00000000000000000000"),
TestVector.Create(-1L, "09223372036854775807"),
TestVector.Create(0L, "09223372036854775808"),
TestVector.Create(+1L, "09223372036854775809"),
TestVector.Create(long.MaxValue, "18446744073709551615"),
};
var d = new[] {
TestVector.Create(0UL, "00000000000000000000"),
TestVector.Create(1UL, "00000000000000000001"),
TestVector.Create((ulong)uint.MaxValue + 1, "00000000004294967296"),
TestVector.Create(ulong.MaxValue, "18446744073709551615"),
};
var q = new[] {
TestBuilder
.NewTestVectorTest(a, converter, converter.Encode)
.Create(),
TestBuilder
.NewTestVectorTest(b, converter, converter.Encode)
.Create(),
TestBuilder
.NewTestVectorTest(c, converter, converter.Encode)
.Create(),
TestBuilder
.NewTestVectorTest(d, converter, converter.Encode)
.Create(),
};
foreach (var test in q)
{
test();
}
}
public override string Encode(object data)
{
TestVector vec = data as TestVector;
if (vec == null)
{
return("null");
}
else
{
return($"<{vec.x},{vec.y},{vec.z}>");
}
}
public static Vector<Complex32> Vector(TestVector vector)
{
switch (vector)
{
case TestVector.Dense5: return V.Dense(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1), new Complex32(5, 1) });
case TestVector.Dense5WithZeros: return V.Dense(new[] { new Complex32(2, -1), new Complex32(0, 0), new Complex32(0, 2), new Complex32(-5, 1), new Complex32(0, 0) });
case TestVector.Sparse5: return V.SparseOfEnumerable(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1), new Complex32(5, 1) });
case TestVector.Sparse5WithZeros: return V.SparseOfEnumerable(new[] { new Complex32(2, -1), new Complex32(0, 0), new Complex32(0, 2), new Complex32(-5, 1), new Complex32(0, 0) });
case TestVector.Sparse5AllZeros: return V.Sparse(5);
case TestVector.SparseMaxLengthAllZeros: return V.Sparse(int.MaxValue);
default: throw new NotSupportedException();
}
}
public static Vector<float> Vector(TestVector vector)
{
switch (vector)
{
case TestVector.Dense5: return V.Dense(new float[] { 1, 2, 3, 4, 5 });
case TestVector.Dense5WithZeros: return V.Dense(new float[] { 2, 0, 0, -5, 0 });
case TestVector.Sparse5: return V.SparseOfEnumerable(new float[] { 1, 2, 3, 4, 5 });
case TestVector.Sparse5WithZeros: return V.SparseOfEnumerable(new float[] { 2, 0, 0, -5, 0 });
case TestVector.Sparse5AllZeros: return V.Sparse(5);
case TestVector.SparseMaxLengthAllZeros: return V.Sparse(int.MaxValue);
default: throw new NotSupportedException();
}
}
public void TestVectors()
{
using (StreamReader r = new StreamReader(SimpleTest.GetTestDataAsStream("crypto.SHA3TestVectors.txt")))
{
String line;
while (null != (line = ReadLine(r)))
{
if (line.Length != 0)
{
TestVector v = ReadTestVector(r, line);
RunTestVector(v);
}
}
}
}
public void ObjectReassignment()
{
TestNested target = new TestNested();
target.str = "somevalue";
target.testVec = new TestVector();
ReflectedObject root = new ReflectedObject(target);
TestVector testVec = new TestVector();
testVec.vec = new Vector3(-1f, -2f, -3f);
root["testVec"].Value = testVec;
Assert.AreEqual(root["testVec"]["vec"]["x"].Value, -1f);
Assert.AreEqual(root["testVec"]["vec"]["y"].Value, -2f);
Assert.AreEqual(root["testVec"]["vec"]["z"].Value, -3f);
Assert.AreNotEqual(root["testVec"].Value, target.testVec);
}
public void WriteStruct()
{
TestVector target = new TestVector();
target.vec = new Vector3(4f, 5f, 6f);
ReflectedObject root = new ReflectedObject(target);
Assert.AreEqual(root["vec"]["x"].Value, 4f);
Assert.AreEqual(root["vec"]["y"].Value, 5f);
Assert.AreEqual(root["vec"]["z"].Value, 6f);
root["vec"]["x"].Value = 7f;
root["vec"]["y"].Value = 8f;
root["vec"]["z"].Value = 9f;
Assert.AreEqual(root["vec"]["x"].Value, 7f);
Assert.AreEqual(root["vec"]["y"].Value, 8f);
Assert.AreEqual(root["vec"]["z"].Value, 9f);
}
/// <summary>
/// </summary>
/// <param name="test">
/// </param>
private static void RunTest(TestVector test)
{
var constHash = "Bitcoin seed".Select(Convert.ToByte).ToArray();
var headers = new CoinParameters {
PublicKeyAddressVersion = 0, PrivateKeyVersion = 128
};
var seed = CryptoUtil.ConvertHex(test.strHexMaster);
var key = ExtendedKey.Create(constHash, seed);
var pubkey = key.GetPublicKey();
foreach (var derive in test.vDerive)
{
var skey = key.Serialize();
var spubkey = pubkey.Serialize();
Guard.Require(skey == derive.prv);
Guard.Require(spubkey == derive.pub);
var pkey = ExtendedKey.Parse(derive.prv);
var ppubkey = ExtendedKey.Parse(derive.pub);
var wif1 = pkey.GetKey(1).PrivateKey.ToWifKey(headers);
var wif2 = key.GetKey(1).PrivateKey.ToWifKey(headers);
Guard.Require(wif1 == wif2);
var addr1 = ppubkey.GetKey(1).PublicKey.ToAddress(headers);
var addr2 = pubkey.GetKey(1).ToAddress(headers);
Guard.Require(addr1.ToString() == addr2.ToString());
key = key.GetChild(derive.nChild);
if ((derive.nChild & 0x80000000) == 0)
{
var pubkeyn = pubkey.GetChild(derive.nChild);
pubkey = key.GetPublicKey();
Guard.Require(pubkey.Master.ToAddress(headers).ToString() == pubkeyn.Master.ToAddress(headers).ToString());
}
else
{
pubkey = key.GetPublicKey();
}
}
}
public void ApplyModifiedProperties_Object()
{
TestNested target = new TestNested();
target.str = "somevalue";
target.testVec = new TestVector();
ReflectedObject root = new ReflectedObject(target);
TestVector testVec = new TestVector();
testVec.vec = new Vector3(-1f, -2f, -3f);
root["testVec"].Value = testVec;
Assert.AreNotEqual(root["testVec"].Value, target.testVec);
root.ApplyModifiedProperties();
Assert.AreEqual(root["testVec"].Value, target.testVec);
root["testVec"]["vec"]["x"].Value = 99f;
Assert.AreNotEqual(99f, target.testVec.vec.x);
root.ApplyModifiedProperties();
Assert.AreEqual(99f, target.testVec.vec.x);
}
public static Vector <Complex32> Vector(TestVector vector)
{
switch (vector)
{
case TestVector.Dense5: return(V.Dense(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1), new Complex32(5, 1) }));
case TestVector.Dense5WithZeros: return(V.Dense(new[] { new Complex32(2, -1), new Complex32(0, 0), new Complex32(0, 2), new Complex32(-5, 1), new Complex32(0, 0) }));
case TestVector.Sparse5: return(V.SparseOfEnumerable(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1), new Complex32(5, 1) }));
case TestVector.Sparse5WithZeros: return(V.SparseOfEnumerable(new[] { new Complex32(2, -1), new Complex32(0, 0), new Complex32(0, 2), new Complex32(-5, 1), new Complex32(0, 0) }));
case TestVector.Sparse5AllZeros: return(V.Sparse(5));
case TestVector.SparseMaxLengthAllZeros: return(V.Sparse(int.MaxValue));
default: throw new NotSupportedException();
}
}
public static Vector <float> Vector(TestVector vector)
{
switch (vector)
{
case TestVector.Dense5: return(V.Dense(new float[] { 1, 2, 3, 4, 5 }));
case TestVector.Dense5WithZeros: return(V.Dense(new float[] { 2, 0, 0, -5, 0 }));
case TestVector.Sparse5: return(V.SparseOfEnumerable(new float[] { 1, 2, 3, 4, 5 }));
case TestVector.Sparse5WithZeros: return(V.SparseOfEnumerable(new float[] { 2, 0, 0, -5, 0 }));
case TestVector.Sparse5AllZeros: return(V.Sparse(5));
case TestVector.SparseMaxLengthAllZeros: return(V.Sparse(int.MaxValue));
default: throw new NotSupportedException();
}
}
public void CanNegateVector(TestVector testVector)
{
Vector <T> vector = Get(testVector);
var hash = vector.GetHashCode();
var result1 = -vector;
var result2 = vector.Negate();
Assert.That(vector.GetHashCode(), Is.EqualTo(hash));
Assert.That(result1, Is.Not.SameAs(vector));
Assert.That((-result1).Equals(vector));
Assert.That(result2, Is.Not.SameAs(vector));
Assert.That((-result2).Equals(vector));
Assert.That(result1.Equals(result2));
for (var i = 0; i < Math.Min(vector.Count, 20); i++)
{
Assert.That(result1[i], Is.EqualTo(Operator.Negate(vector[i])));
Assert.That(result2[i], Is.EqualTo(Operator.Negate(vector[i])));
}
}
public void SetUp()
{
string email = "*****@*****.**";
string mobile = "0425123214";
string firstName = "Timothy";
string lastName = "Xing";
string password = "******";
string passwordConfirm = "Member@123";
try
{
_testVector = GenerateTestVector(email, mobile, firstName, lastName, password, passwordConfirm);
_driver = new ChromeDriver();
_registerURL = "https://localhost:44309/Identity/Account/Register";
_driver.Navigate().GoToUrl(_registerURL);
Thread.Sleep(1000);
}
catch (Exception ex)
{
_logger.Error(ex.Message);
throw new Exception(ex.Message);
}
}
public void CanEqualVector(TestVector testVector, T scalar)
{
Vector <T> vector = Get(testVector);
Assert.That(vector.Equals(vector));
var a = vector.Clone();
Assert.That(a, Is.Not.SameAs(vector));
Assert.That(a.Equals(vector), Is.True);
var a0 = a.At(0);
var a0Equals = a0.Equals(scalar);
a.At(0, scalar);
Assert.That(a.Equals(vector), Is.EqualTo(a0Equals));
Assert.That(vector.Equals(a), Is.EqualTo(a0Equals));
var b = vector.Clone();
var b1 = b.At(1);
var b1Equals = b1.Equals(scalar);
b.At(1, scalar);
Assert.That(b.Equals(vector), Is.EqualTo(b1Equals));
Assert.That(vector.Equals(b), Is.EqualTo(b1Equals));
Assert.That(a.Equals(b), Is.EqualTo(a0Equals && b1Equals));
a.At(0, a0);
Assert.That(a.Equals(vector), Is.True);
Assert.That(vector.Equals(a), Is.True);
var c = vector.Clone();
c.Subtract(vector, c);
Assert.That(c.Equals(Vector <T> .Build.SameAs(vector)));
}
public void SetUp()
{
string email = "*****@*****.**";
string mobile = "0425123214";
string guestName = "Timothy Xing";
DateTime startDateTime = new DateTime(2020, 05, 25, 08, 00, 00);
string duration = "1.0 hour";
int numberOfGuest = 12;
string requirement = "Close to window";
try
{
_testVector = GenerateTestVector(email, mobile, guestName, startDateTime, duration, numberOfGuest, requirement);
_driver = new ChromeDriver();
_registerURL = "https://localhost:44309/Reservation/Create";
_driver.Navigate().GoToUrl(_registerURL);
Thread.Sleep(1000);
}
catch (Exception ex)
{
_logger.Error(ex.Message);
throw new Exception(ex.Message);
}
}
public override object Decode(string data)
{
if (data.ToLower().Equals("null"))
{
return(null);
}
else
{
try
{
string interior = data.Substring(1, data.Length - 2);
string[] comp = interior.Split(',');
TestVector val = new TestVector();
val.x = int.Parse(comp[0]);
val.y = int.Parse(comp[1]);
val.z = int.Parse(comp[2]);
return(val);
}
catch
{
return(null);
}
}
}
public void CanSubtractScalarFromVector(TestVector testVector, T scalar)
{
Vector <T> vector = Get(testVector);
Assume.That(vector.Count, Is.LessThan(100));
var hash = vector.GetHashCode();
var result1 = vector.Subtract(scalar);
var result2 = vector.Clone();
result2.Subtract(scalar, result2);
Assert.That(vector.GetHashCode(), Is.EqualTo(hash));
Assert.That(result1, Is.Not.SameAs(vector));
Assert.That(result2, Is.Not.SameAs(vector));
Assert.That(result1.Equals(result2));
for (var i = 0; i < Math.Min(vector.Count, 20); i++)
{
Assert.That(result1[i], Is.EqualTo(Operator.Subtract(vector[i], scalar)));
Assert.That(result2[i], Is.EqualTo(Operator.Subtract(vector[i], scalar)));
}
}
private void RunTestVector(TestVector v)
{
int bits = v.Bits;
int partialBits = bits % 8;
//Console.WriteLine(v.Algorithm + " " + bits + "-bit");
//Console.WriteLine(Hex.ToHexString(v.Message).ToUpper());
//Console.WriteLine(Hex.ToHexString(v.Hash).ToUpper());
MySha3Digest d = CreateDigest(v.Algorithm);
byte[] output = new byte[d.GetDigestSize()];
byte[] m = v.Message;
if (partialBits == 0)
{
d.BlockUpdate(m, 0, m.Length);
d.DoFinal(output, 0);
}
else
{
d.BlockUpdate(m, 0, m.Length - 1);
d.MyDoFinal(output, 0, m[m.Length - 1], partialBits);
}
if (!Arrays.AreEqual(v.Hash, output))
{
Fail(v.Algorithm + " " + v.Bits + "-bit test vector hash mismatch");
//Console.Error.WriteLine(v.Algorithm + " " + v.Bits + "-bit test vector hash mismatch");
//Console.Error.WriteLine(Hex.ToHexString(output).ToUpper());
}
}
protected override Vector <Complex32> Get(TestVector vector)
{
return(TestData.Vector(vector));
}
protected override Vector <double> Get(TestVector vector)
{
return(TestData.Vector(vector));
}
private void RunTestVector(TestVector v)
{
int bits = v.Bits;
int partialBits = bits % 8;
byte[] expected = v.Output;
//Console.WriteLine(v.Algorithm + " " + bits + "-bit");
//Console.WriteLine(Hex.ToHexString(v.Message).ToUpper());
//Console.WriteLine(Hex.ToHexString(expected).ToUpper());
int outLen = expected.Length;
MyShakeDigest d = CreateDigest(v.Algorithm);
byte[] output = new byte[outLen];
byte[] m = v.Message;
if (partialBits == 0)
{
d.BlockUpdate(m, 0, m.Length);
d.DoFinal(output, 0, outLen);
}
else
{
d.BlockUpdate(m, 0, m.Length - 1);
d.MyDoFinal(output, 0, outLen, m[m.Length - 1], partialBits);
}
if (!Arrays.AreEqual(expected, output))
{
Fail(v.Algorithm + " " + v.Bits + "-bit test vector hash mismatch");
//Console.Error.WriteLine(v.Algorithm + " " + v.Bits + "-bit test vector hash mismatch");
//Console.Error.WriteLine(Hex.ToHexString(output).ToUpper());
}
if (partialBits == 0)
{
d = CreateDigest(v.Algorithm);
m = v.Message;
d.BlockUpdate(m, 0, m.Length);
d.DoOutput(output, 0, outLen / 2);
d.DoOutput(output, outLen / 2, output.Length - outLen / 2);
if (!Arrays.AreEqual(expected, output))
{
Fail(v.Algorithm + " " + v.Bits + "-bit test vector extended hash mismatch");
}
try
{
d.Update((byte)0x01);
Fail("no exception");
}
catch (InvalidOperationException e)
{
if (!"attempt to absorb while squeezing".Equals(e.Message))
{
Fail("wrong exception");
}
}
d = CreateDigest(v.Algorithm);
m = v.Message;
d.BlockUpdate(m, 0, m.Length);
d.DoOutput(output, 0, outLen / 2);
d.DoFinal(output, outLen / 2, output.Length - outLen / 2);
if (!Arrays.AreEqual(expected, output))
{
Fail(v.Algorithm + " " + v.Bits + "-bit test vector extended doFinal hash mismatch");
}
d.Update((byte)0x01); // this should be okay as we've reset on DoFinal()
}
}
