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))); } }
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() } }