public void Unify_UnknownType() { var unifier = new TypeUnifier(); var ts = new FakeType(); Assert.ThrowsException <NotSupportedException>(() => unifier.Unify(typeof(int), ts)); }
public void CreateResponseFromObject() { var stubbedData = new FakeType { SomeId = 42, SomeData = "the meaning of life" }; var response = new EsiResponse <FakeType>(HttpStatusCode.OK, stubbedData); var httpResponse = new HttpResponseMessage { StatusCode = HttpStatusCode.OK, Content = new StringContent(JsonSerializer.Serialize(stubbedData)) }; var result = _responseFactory.Create <FakeType>(httpResponse); if (!(result.Data is null)) { Assert.AreEqual(response.Data !.SomeId, result.Data.SomeId); Assert.AreEqual(response.Data !.SomeData, result.Data.SomeData); Assert.IsNull(result.Error); Assert.IsNull(result.Message); }
public void CreateFake(FakeType fakeType) { TripViewModel fake; if (fakeType == FakeType.Trip) { TripViewModel fakeTrip = this.Items.FirstOrDefault(p => p.Identifier == -1); if (fakeTrip != null) this.Items.Remove(fakeTrip); fake = new TripViewModel() { Identifier = -1, Title = "New Trip?", Description = "Click here to add a trip", LocalPathImage = "Assets/NewTrip.png", }; } else { fake = new TripViewModel() { Identifier = -1, Title = "Comming Soon", Description = "We are working", LocalPathImage = "Assets/Suggestion.png", IsSuggestion = true, }; } fake.ItemGroups.Clear(); fake.ItemGroups = new ObservableCollection<CategoryViewModel>(); this.Items.Add(fake); }
/// <summary> /// Creates a new sum proof. /// </summary> /// <param name="r">The randomness used to encrypt the vote.</param> /// <param name="voteSum">The sum of all votes for which to generate a proof.</param> /// <param name="publicKey">The public key with which the vote was encrypted.</param> /// <param name="parameters">Cryptographic Parameters.</param> /// /// <param name="fakeType">What fake to create?</param> public Proof(BigInt r, Vote voteSum, BigInt publicKey, BaseParameters parameters, FakeType fakeType) { if (r == null) throw new ArgumentNullException("r"); if (voteSum == null) throw new ArgumentNullException("vote"); if (publicKey == null) throw new ArgumentNullException("publicKey"); if (parameters == null) throw new ArgumentNullException("parameters"); BigInt r0 = parameters.Random(); MemoryStream serializeStream = new MemoryStream(); SerializeContext serializer = new SerializeContext(serializeStream); SHA512Managed sha512 = new SHA512Managed(); switch (fakeType) { case FakeType.BadFiatShamir: T0 = publicKey.PowerMod(r0, parameters.P); serializer.Write(voteSum.Ciphertext); serializer.Write(voteSum.HalfKey); serializer.Write(publicKey); serializer.Write(T0); serializer.Close(); serializeStream.Close(); byte[] hash0 = sha512.ComputeHash(serializeStream.ToArray()); C0 = 0; S0 = r0 + r * C0; break; case FakeType.BadPowerMod: T0 = publicKey.PowerMod(0, parameters.P); serializer.Write(voteSum.Ciphertext); serializer.Write(voteSum.HalfKey); serializer.Write(publicKey); serializer.Write(T0); serializer.Close(); serializeStream.Close(); byte[] hash1 = sha512.ComputeHash(serializeStream.ToArray()); C0 = hash1[0] | (hash1[1] << 8); S0 = 1; break; default: throw new NotSupportedException("Cannot generate that type of fake."); } }
public void TrueSpecification_ReturnTrue <T>(FakeType candidate, Expression <Func <FakeType, T> > selector) { var specification = MockSpecification <T> .True(); var sut = new PropertySpecification <FakeType, T>(selector, specification); var result = sut.IsSatisfiedBy(candidate); Assert.True(result); }
public virtual void Get_named_mappings_for_sql_type(string typeName, string udtName) { var type = new FakeType(typeName); var mapping = GetMapping(type); Assert.Equal(udtName, mapping.StoreType); Assert.Equal(udtName, ((SqlServerUdtTypeMapping)mapping).UdtTypeName); Assert.Same(type, mapping.ClrType); }
public void InvokeTrueSpecification_ReturnTrue <T>(FakeType candidate, Expression <Func <FakeType, T> > selector) { var specification = MockSpecification <T> .True(); var sut = new PropertySpecification <FakeType, T>(selector, specification); var result = sut.GetExpression().Compile().Invoke(candidate); Assert.True(result); }
public void InvokeCastToInterfaceType_ReturnTrue() { var candidate = new FakeType(); var specification = MockSpecification <IEnumerable <char> > .True(); var sut = new CastSpecification <FakeType, IEnumerable <char> >(specification); var result = sut.GetExpression().Compile().Invoke(candidate); Assert.True(result); }
public void FalseSpecification_ReturnFalse <T>(FakeType candidate, Expression <Func <FakeType, T> > selector) { candidate = candidate.Second != "null" ? candidate : null; var specification = MockSpecification <T> .False(); var sut = new PropertySpecification <FakeType, T>(selector, specification); var result = sut.IsSatisfiedBy(candidate); Assert.False(result); }
public void CastToInterfaceType_ReturnTrue() { var candidate = new FakeType(); var specification = MockSpecification <IEnumerable <char> > .True(); var sut = new CastSpecification <FakeType, IEnumerable <char> >(specification); var result = sut.IsSatisfiedBy(candidate); Assert.True(result); }
public void TrueSpecification_ReturnExpectedResultObject <T>(FakeType candidate, Expression <Func <FakeType, T> > selector, SpecificationResult expected) { ISpecification <T> specification = MockValidationSpecification <T> .True(); var sut = new PropertySpecification <FakeType, T>(selector, specification); var overall = sut.IsSatisfiedBy(candidate, out var result); Assert.True(overall); Assert.Equal(expected, result, new SpecificationResultComparer()); }
private static TypeReference CreateTypeReference(FakeType fakeType) { if (fakeType == null) { return(null); } var monoCecilTypeReference = CreateMockFor <TypeReference>(); monoCecilTypeReference.Setup(reference => reference.Name).Returns(() => fakeType.FullName.Split('.').Last()); monoCecilTypeReference.Setup(reference => reference.FullName).Returns(() => fakeType.FullName); return(monoCecilTypeReference.Object); }
private static MonoCecilTypeReference CreateMonoCecilTypeReference(FakeType fakeType) { if (fakeType == null) { return(null); } var monoCecilTypeReference = new Mock <MonoCecilTypeReference>(null); monoCecilTypeReference.Setup(reference => reference.Name).Returns(() => fakeType.Name); monoCecilTypeReference.Setup(reference => reference.FullName).Returns(() => fakeType.FullName); return(monoCecilTypeReference.Object); }
public virtual void Get_named_mappings_for_sql_type(string typeName, string udtName) { var mapper = (IRelationalTypeMappingSource) new SqlServerTypeMappingSource( TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(), TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>()); var type = new FakeType(typeName); var mapping = mapper.FindMapping(type); Assert.Equal(udtName, mapping.StoreType); Assert.Equal(udtName, ((SqlServerUdtTypeMapping)mapping).UdtTypeName); Assert.Same(type, mapping.ClrType); }
public void CastToInterfaceType_ReturnExpectedResultObject() { var candidate = new FakeType(); var specification = MockSpecification <IEnumerable <char> > .True(); var expected = new SpecificationResult(2, true, "CastSpecification<FakeType,IEnumerable<Char>>(TrueMockSpecification<IEnumerable<Char>>)"); var sut = new CastSpecification <FakeType, IEnumerable <char> >(specification); var overall = sut.IsSatisfiedBy(candidate, out var result); Assert.True(overall); Assert.Equal(expected, result, new SpecificationResultComparer()); }
private static ReflectionType CreateReflectionType(FakeType fakeType) { if (fakeType == null) { return(null); } var reflectionType = new Mock <ReflectionType>(fakeType.Type); reflectionType.Setup(reference => reference.Name).Returns(() => fakeType.Name); reflectionType.Setup(reference => reference.FullName).Returns(() => fakeType.FullName); return(reflectionType.Object); }
public ComplexData() { AddValid(1) .Result("MockCommonSpecification<Int32>") .NegationResult("NotMockCommonSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(MockCommonSpecification <int>), "Match") .Candidate(1)); AddValid(1.5) .Result("MockCommonSpecification<Double>") .NegationResult("NotMockCommonSpecification<Double>+Failed", c => c .FailedSpecification(typeof(MockCommonSpecification <double>), "Match") .Candidate(1.5)); AddValid(true) .Result("MockCommonSpecification<Boolean>") .NegationResult("NotMockCommonSpecification<Boolean>+Failed", c => c .FailedSpecification(typeof(MockCommonSpecification <bool>), "Match") .Candidate(true)); AddValid(BindingFlags.NonPublic) .Result("MockCommonSpecification<BindingFlags>") .NegationResult("NotMockCommonSpecification<BindingFlags>+Failed", c => c .FailedSpecification(typeof(MockCommonSpecification <BindingFlags>), "Match") .Candidate(BindingFlags.NonPublic)); var obj = new object(); var list = new List <int>(); var fake = new FakeType(); AddInvalid(obj) .Result("MockCommonSpecification<Object>+Failed", c => c .FailedSpecification(typeof(MockCommonSpecification <object>), "Not match") .Candidate(obj)) .NegationResult("NotMockCommonSpecification<Object>"); AddInvalid(list) .Result("MockCommonSpecification<List<Int32>>+Failed", c => c .FailedSpecification(typeof(MockCommonSpecification <List <int> >), "Not match") .Candidate(list)) .NegationResult("NotMockCommonSpecification<List<Int32>>"); AddInvalid(fake) .Result("MockCommonSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(MockCommonSpecification <FakeType>), "Not match") .Candidate(fake)) .NegationResult("NotMockCommonSpecification<FakeType>"); AddInvalid("") .Result("MockCommonSpecification<String>+Failed", c => c .FailedSpecification(typeof(MockCommonSpecification <string>), "Not match") .Candidate("")) .NegationResult("NotMockCommonSpecification<String>"); }
public void FalseSpecification_ReturnExpectedResultObject <T>(FakeType candidate, Expression <Func <FakeType, T> > selector, SpecificationResult expected) { candidate = candidate.Second != "null" ? candidate : null; ISpecification <T> specification = MockComplexSpecification <T> .False(); var sut = new PropertySpecification <FakeType, T>(selector, specification); var overall = sut.IsSatisfiedBy(candidate, out var result); Assert.False(overall); Assert.Equal(expected, result, new SpecificationResultComparer( parameters: new Dictionary <string, object> { { "PropertySpecification", specification } })); }
private void PutParameterDescriptions(MethodInfo methodInfo, IList <ApiParameterDescription> apiParameters) { if (!methodInfo.GetParameters().Any()) { return; } Type argumentType = new FakeType(methodInfo); apiParameters.Add(new ApiParameterDescription { Name = "Arguments", Type = argumentType, ModelMetadata = new RequestTypeMetadata(argumentType, methodInfo.GetParameters().Select(x => new ParameterMetadata(x))), Source = BindingSource.Body }); }
public PropertyExpressionData() { var candidate = new FakeType { First = 1, Second = "2", Inter = new InterFakeType() }; var empty = new FakeType(); var ftSecondSelector = (Expression <Func <FakeType, string> >)(ft => ft.Second); var ftThirdSelector = (Expression <Func <FakeType, bool> >)(ft => ft.Inter.Third); AddValid(candidate, ftSecondSelector); AddValid(candidate, ftThirdSelector); AddValid(empty, ftSecondSelector); AddInvalid(candidate, ftSecondSelector); AddInvalid(candidate, ftThirdSelector); }
/// <summary> /// Creates a new encrypted vote with an invalid proof. /// </summary> /// <remarks> /// Includes invalid zero-knowledge proves of vote being 0 or 1 when it is not. /// </remarks> /// <param name="votum">Actual vote.</param> /// <param name="parameters">Cryptographic parameters.</param> /// <param name="publicKey">Public key of the authorities.</param> /// <param name="fakeType">What kind of a fake?</param> public Vote(int votum, BigInt nonce, BaseParameters parameters, BigInt publicKey, FakeType fakeType) { if (votum.InRange(0, 1)) throw new ArgumentException("Cannot create a invalid proof of a valid votum."); if (nonce == null) throw new ArgumentNullException("nonce"); if (parameters == null) throw new ArgumentNullException("parameters"); if (publicKey == null) throw new ArgumentNullException("publicKey"); P = parameters.P; HalfKey = parameters.G.PowerMod(nonce, P); //The 12 magic number is inserted to avoid division remainders when //dividing partial deciphers for linear combinations by 2, 3 and 4. Ciphertext = (publicKey.PowerMod(nonce * 12, P) * parameters.F.PowerMod(votum, P)).Mod(P); RangeProves = new List<RangeProof>(); for (int proofIndex = 0; proofIndex < parameters.ProofCount; proofIndex++) { RangeProves.Add(new RangeProof(votum, nonce * 12, this, publicKey, parameters, fakeType)); } }
public FakeCommonTypeBuilder AddProperty(string name, FakeType propertyType, PropertyMethods propertyMethods, params Attribute[] propertyAttributes) { return(AddProperty(name, propertyType, propertyMethods, propertyAttributes.Select(attribute => new FakeAttribute(attribute)).ToArray())); }
public CannotBeActivatedController(FakeType service) { }
/// <summary> /// Creates a new invalid range proof. /// </summary> /// <remarks> /// Used to test proofing mechanism. /// </remarks> /// <param name="votum">The votum. Must NOT be 0 or 1.</param> /// <param name="r">The randomness used to encrypt the vote.</param> /// <param name="vote">The vote for which to generate a proof.</param> /// <param name="publicKey">The public key with which the vote was encrypted.</param> /// <param name="parameters">Cryptographic Parameters.</param> /// <param name="fakeType">What is to be wrong?</param> public RangeProof(int votum, BigInt r, Vote vote, BigInt publicKey, BaseParameters parameters, FakeType fakeType) { if (r == null) throw new ArgumentNullException("r"); if (vote == null) throw new ArgumentNullException("vote"); if (publicKey == null) throw new ArgumentNullException("publicKey"); if (parameters == null) throw new ArgumentNullException("parameters"); BigInt r0 = parameters.Random(); BigInt r1 = parameters.Random(); MemoryStream serializeStream = new MemoryStream(); SerializeContext serializer = new SerializeContext(serializeStream); SHA512Managed sha512 = new SHA512Managed(); switch (fakeType) { case FakeType.BadDisjunction: //The C value will not be correct as it is not considered. //Create the fake proof. C0 = (int)Prime.RandomNumber(16); S0 = parameters.Random(); T0 = (vote.Ciphertext.DivideMod(parameters.F.PowerMod(0, parameters.P), parameters.P).PowerMod(C0, parameters.P).InvertMod(parameters.P) * publicKey.PowerMod(S0, parameters.P)).Mod(parameters.P); //Create the fake proof. C1 = (int)Prime.RandomNumber(16); S1 = parameters.Random(); T1 = (vote.Ciphertext.DivideMod(parameters.F.PowerMod(1, parameters.P), parameters.P).PowerMod(C1, parameters.P).InvertMod(parameters.P) * publicKey.PowerMod(S1, parameters.P)).Mod(parameters.P); //Put togeather the data to be hashed. serializer.Write(vote.Ciphertext); serializer.Write(vote.HalfKey); serializer.Write(publicKey); serializer.Write(T0); serializer.Write(T1); serializer.Close(); serializeStream.Close(); //Hash the proof data. byte[] hash0 = sha512.ComputeHash(serializeStream.ToArray()); //Take the first 16 bits. C = hash0[0] | (hash0[1] << 8); break; case FakeType.BadFiatShamir: //The C value will not correspond to the hash. //Create the fake proof. C0 = (int)Prime.RandomNumber(16); S0 = parameters.Random(); T0 = (vote.Ciphertext.DivideMod(parameters.F.PowerMod(0, parameters.P), parameters.P).PowerMod(C0, parameters.P).InvertMod(parameters.P) * publicKey.PowerMod(S0, parameters.P)).Mod(parameters.P); //Create the fake proof. C1 = (int)Prime.RandomNumber(16); S1 = parameters.Random(); T1 = (vote.Ciphertext.DivideMod(parameters.F.PowerMod(1, parameters.P), parameters.P).PowerMod(C1, parameters.P).InvertMod(parameters.P) * publicKey.PowerMod(S1, parameters.P)).Mod(parameters.P); //Put togeather the data to be hashed. serializer.Write(vote.Ciphertext); serializer.Write(vote.HalfKey); serializer.Write(publicKey); serializer.Write(T0); serializer.Write(T1); serializer.Close(); serializeStream.Close(); //Hash the proof data. byte[] hash1 = sha512.ComputeHash(serializeStream.ToArray()); //Take the first 16 bits. C = C0 + C1; break; case FakeType.BadPowerMod: //Create the fake proof. C1 = (int)Prime.RandomNumber(16); S1 = parameters.Random(); T1 = (vote.Ciphertext.DivideMod(parameters.F.PowerMod(1, parameters.P), parameters.P).PowerMod(C1, parameters.P).InvertMod(parameters.P) * publicKey.PowerMod(S1, parameters.P)).Mod(parameters.P); //First part of the real proof T0 = publicKey.PowerMod(r0, parameters.P); //Put togeather the data to be hashed. serializer.Write(vote.Ciphertext); serializer.Write(vote.HalfKey); serializer.Write(publicKey); serializer.Write(T0); serializer.Write(T1); serializer.Close(); serializeStream.Close(); //Hash the proof data. byte[] hash2 = sha512.ComputeHash(serializeStream.ToArray()); //Take the first 16 bits. C = hash2[0] | (hash2[1] << 8); //Second part of the real proof C0 = (int)((BigInt)(C - C1)).Mod(0xffff); S0 = r0 + r * C0; break; default: throw new NotSupportedException("Cannot fake in that way."); } }
public FakeCommonTypeBuilder AddMethod(string name, FakeType returnType, FakeParameter[] parameters) { return(AddMethod(name, returnType, parameters, (FakeAttribute[])null)); }
public FakeCommonTypeBuilder AddField(string name, FakeType fieldType, params FakeAttribute[] fieldFakeAttributes) { fields.Add(new FakeField(name, fieldType, fieldFakeAttributes)); return(this); }
public CannotBeActivatedComponent(FakeType fakeType) { }
public FakeCommonTypeBuilder AddMethod(string name, FakeType returnType, FakeParameter[] parameters, params Attribute[] methodAttributes) { return(AddMethod(name, returnType, parameters, methodAttributes.Select(attribute => new FakeAttribute(attribute)).ToArray())); }
public FakeCommonTypeBuilder AddMethod(string name, FakeType returnType, FakeParameter[] parameters, params FakeAttribute[] methodFakeAttributes) { methods.Add(new FakeMethod(name, returnType, parameters, methodFakeAttributes)); return(this); }
public ExclusiveBetweenData() { var comparer = new FakeTypeComparer(); var intComparer = new FakeIntComparer(); ComparableFakeType cmp = new ComparableFakeType { First = 15 }, cmpFrom = new ComparableFakeType { First = 1 }, cmpTo = new ComparableFakeType { First = 30 }; FakeType cmpFakeType = new FakeType { First = 15 }, cmpFromFakeType = new FakeType { First = 1 }, cmpToFakeType = new FakeType { First = 30 }; AddValid(1, 0, 5, null) .Result("ExclusiveBetweenSpecification<Int32>") .NegationResult("NotExclusiveBetweenSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <int>), "Value is between [0] and [5]") .Candidate(1) .AddParameter("From", 0) .AddParameter("To", 5)); AddValid(-1, -5, 1, null) .Result("ExclusiveBetweenSpecification<Int32>") .NegationResult("NotExclusiveBetweenSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <int>), "Value is between [-5] and [1]") .Candidate(-1) .AddParameter("From", -5) .AddParameter("To", 1)); AddValid(-9, -24, -1, intComparer) .Result("ExclusiveBetweenSpecification<Int32>") .NegationResult("NotExclusiveBetweenSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <int>), "Value is between [-24] and [-1]") .Candidate(-9) .AddParameter("From", -24) .AddParameter("To", -1)); AddValid(5.74, 5.73, 5.75, null) .Result("ExclusiveBetweenSpecification<Double>") .NegationResult("NotExclusiveBetweenSpecification<Double>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <double>), "Value is between [5.73] and [5.75]") .Candidate(5.74) .AddParameter("From", 5.73) .AddParameter("To", 5.75)); AddValid(-2.5, -3.0, 0.0, null) .Result("ExclusiveBetweenSpecification<Double>") .NegationResult("NotExclusiveBetweenSpecification<Double>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <double>), "Value is between [-3] and [0]") .Candidate(-2.5) .AddParameter("From", -3.0) .AddParameter("To", 0.0)); AddValid(-5.75, -5.76, -5.74, null) .Result("ExclusiveBetweenSpecification<Double>") .NegationResult("NotExclusiveBetweenSpecification<Double>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <double>), "Value is between [-5.76] and [-5.74]") .Candidate(-5.75) .AddParameter("From", -5.76) .AddParameter("To", -5.74)); AddValid("123", "122", "124", null) .Result("ExclusiveBetweenSpecification<String>") .NegationResult("NotExclusiveBetweenSpecification<String>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <string>), "Value is between [122] and [124]") .Candidate("123") .AddParameter("From", "122") .AddParameter("To", "124")); AddValid("123", "12", "1234", null) .Result("ExclusiveBetweenSpecification<String>") .NegationResult("NotExclusiveBetweenSpecification<String>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <string>), "Value is between [12] and [1234]") .Candidate("123") .AddParameter("From", "12") .AddParameter("To", "1234")); AddValid("test", null, "test1", null) .Result("ExclusiveBetweenSpecification<String>") .NegationResult("NotExclusiveBetweenSpecification<String>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <string>), "Value is between [null] and [test1]") .Candidate("test") .AddParameter("From", null) .AddParameter("To", "test1")); AddValid(DateTime.Parse("2018-01-15"), DateTime.Parse("2017-05-16"), DateTime.Parse("2019-07-11"), null) .Result("ExclusiveBetweenSpecification<DateTime>") .NegationResult("NotExclusiveBetweenSpecification<DateTime>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <DateTime>), $"Value is between \\[{DateTimeRegexPattern}\\] and \\[{DateTimeRegexPattern}\\]") .Candidate(DateTime.Parse("2018-01-15")) .AddParameter("From", DateTime.Parse("2017-05-16")) .AddParameter("To", DateTime.Parse("2019-07-11"))); AddValid(DateTime.Parse("2019-07-05"), DateTime.Parse("2019-07-01"), DateTime.Parse("2019-07-11"), null) .Result("ExclusiveBetweenSpecification<DateTime>") .NegationResult("NotExclusiveBetweenSpecification<DateTime>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <DateTime>), $"Value is between \\[{DateTimeRegexPattern}\\] and \\[{DateTimeRegexPattern}\\]") .Candidate(DateTime.Parse("2019-07-05")) .AddParameter("From", DateTime.Parse("2019-07-01")) .AddParameter("To", DateTime.Parse("2019-07-11"))); AddValid(cmp, cmpFrom, cmpTo, null) .Result("ExclusiveBetweenSpecification<ComparableFakeType>") .NegationResult("NotExclusiveBetweenSpecification<ComparableFakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <ComparableFakeType>), "Value is between [Fake(1)] and [Fake(30)]") .Candidate(cmp) .AddParameter("From", cmpFrom) .AddParameter("To", cmpTo)); AddValid(cmp, null, cmpTo, null) .Result("ExclusiveBetweenSpecification<ComparableFakeType>") .NegationResult("NotExclusiveBetweenSpecification<ComparableFakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <ComparableFakeType>), "Value is between [null] and [Fake(30)]") .Candidate(cmp) .AddParameter("From", null) .AddParameter("To", cmpTo)); AddValid(cmpFakeType, cmpFromFakeType, cmpToFakeType, comparer) .Result("ExclusiveBetweenSpecification<FakeType>") .NegationResult("NotExclusiveBetweenSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <FakeType>), "Value is between [Fake(1)] and [Fake(30)]") .Candidate(cmpFakeType) .AddParameter("From", cmpFromFakeType) .AddParameter("To", cmpToFakeType)); AddValid(cmpFakeType, null, cmpToFakeType, comparer) .Result("ExclusiveBetweenSpecification<FakeType>") .NegationResult("NotExclusiveBetweenSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <FakeType>), "Value is between [null] and [Fake(30)]") .Candidate(cmpFakeType) .AddParameter("From", null) .AddParameter("To", cmpToFakeType)); ComparableFakeType notCmp1 = new ComparableFakeType { First = 10 }, notCmp2 = new ComparableFakeType { First = 15 }, notCmp3 = new ComparableFakeType { First = 1 }, notCmp4 = new ComparableFakeType { First = 3 }, notCmp5 = new ComparableFakeType { First = 23 }, notCmp6 = new ComparableFakeType { First = 30 }; ComparableInterFakeType cmpInter1 = new ComparableInterFakeType(), cmpInter2 = new ComparableInterFakeType(), cmpInter3 = new ComparableInterFakeType { Third = true }; FakeType notCmpFakeType1 = new FakeType { First = 10 }, notCmpFakeType2 = new FakeType { First = 15 }, notCmpFakeType3 = new FakeType { First = 1 }, notCmpFakeType4 = new FakeType { First = 3 }, notCmpFakeType5 = new FakeType { First = 23 }, notCmpFakeType6 = new FakeType { First = 30 }; AddInvalid(2, 2, 3, null) .NegationResult("NotExclusiveBetweenSpecification<Int32>") .Result("ExclusiveBetweenSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <int>), "Value is not between [2] and [3]") .Candidate(2) .AddParameter("From", 2) .AddParameter("To", 3)); AddInvalid(-2, -3, -2, null) .NegationResult("NotExclusiveBetweenSpecification<Int32>") .Result("ExclusiveBetweenSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <int>), "Value is not between [-3] and [-2]") .Candidate(-2) .AddParameter("From", -3) .AddParameter("To", -2)); AddInvalid(1, -3, -1, null) .NegationResult("NotExclusiveBetweenSpecification<Int32>") .Result("ExclusiveBetweenSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <int>), "Value is not between [-3] and [-1]") .Candidate(1) .AddParameter("From", -3) .AddParameter("To", -1)); AddInvalid(5, 1, 3, null) .NegationResult("NotExclusiveBetweenSpecification<Int32>") .Result("ExclusiveBetweenSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <int>), "Value is not between [1] and [3]") .Candidate(5) .AddParameter("From", 1) .AddParameter("To", 3)); AddInvalid(-1, -10, -5, intComparer) .NegationResult("NotExclusiveBetweenSpecification<Int32>") .Result("ExclusiveBetweenSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <int>), "Value is not between [-10] and [-5]") .Candidate(-1) .AddParameter("From", -10) .AddParameter("To", -5)); AddInvalid(3.5, 3.5, 3.5, null) .NegationResult("NotExclusiveBetweenSpecification<Double>") .Result("ExclusiveBetweenSpecification<Double>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <double>), "Value is not between [3.5] and [3.5]") .Candidate(3.5) .AddParameter("From", 3.5) .AddParameter("To", 3.5)); AddInvalid(-3.5, -3.5, -3.5, null) .NegationResult("NotExclusiveBetweenSpecification<Double>") .Result("ExclusiveBetweenSpecification<Double>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <double>), "Value is not between [-3.5] and [-3.5]") .Candidate(-3.5) .AddParameter("From", -3.5) .AddParameter("To", -3.5)); AddInvalid(5.74, 2.74, 3.74, null) .NegationResult("NotExclusiveBetweenSpecification<Double>") .Result("ExclusiveBetweenSpecification<Double>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <double>), "Value is not between [2.74] and [3.74]") .Candidate(5.74) .AddParameter("From", 2.74) .AddParameter("To", 3.74)); AddInvalid(-3.74, -7.74, -5.74, null) .NegationResult("NotExclusiveBetweenSpecification<Double>") .Result("ExclusiveBetweenSpecification<Double>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <double>), "Value is not between [-7.74] and [-5.74]") .Candidate(-3.74) .AddParameter("From", -7.74) .AddParameter("To", -5.74)); AddInvalid(5.74, -3.74, 5.73, null) .NegationResult("NotExclusiveBetweenSpecification<Double>") .Result("ExclusiveBetweenSpecification<Double>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <double>), "Value is not between [-3.74] and [5.73]") .Candidate(5.74) .AddParameter("From", -3.74) .AddParameter("To", 5.73)); AddInvalid(false, false, true, null) .NegationResult("NotExclusiveBetweenSpecification<Boolean>") .Result("ExclusiveBetweenSpecification<Boolean>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <bool>), "Value is not between [False] and [True]") .Candidate(false) .AddParameter("From", false) .AddParameter("To", true)); AddInvalid("123", "121", "122", null) .NegationResult("NotExclusiveBetweenSpecification<String>") .Result("ExclusiveBetweenSpecification<String>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <string>), "Value is not between [121] and [122]") .Candidate("123") .AddParameter("From", "121") .AddParameter("To", "122")); AddInvalid("1234", "122", "1233", null) .NegationResult("NotExclusiveBetweenSpecification<String>") .Result("ExclusiveBetweenSpecification<String>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <string>), "Value is not between [122] and [1233]") .Candidate("1234") .AddParameter("From", "122") .AddParameter("To", "1233")); AddInvalid("123", "123", "124", null) .NegationResult("NotExclusiveBetweenSpecification<String>") .Result("ExclusiveBetweenSpecification<String>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <string>), "Value is not between [123] and [124]") .Candidate("123") .AddParameter("From", "123") .AddParameter("To", "124")); AddInvalid("null", "test", "test1", null) .NegationResult("NotExclusiveBetweenSpecification<String>") .Result("ExclusiveBetweenSpecification<String>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <string>), "Value is not between [test] and [test1]") .Candidate(null) .AddParameter("From", "test") .AddParameter("To", "test1")); AddInvalid("null", null, "test", null) .NegationResult("NotExclusiveBetweenSpecification<String>") .Result("ExclusiveBetweenSpecification<String>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <string>), "Value is not between [null] and [test]") .Candidate(null) .AddParameter("From", null) .AddParameter("To", "test")); AddInvalid("null", null, null, null) .NegationResult("NotExclusiveBetweenSpecification<String>") .Result("ExclusiveBetweenSpecification<String>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <string>), "Value is not between [null] and [null]") .Candidate(null) .AddParameter("From", null) .AddParameter("To", null)); AddInvalid(DateTime.Parse("2019-11-15"), DateTime.Parse("2019-07-11"), DateTime.Parse("2019-11-15"), null) .NegationResult("NotExclusiveBetweenSpecification<DateTime>") .Result("ExclusiveBetweenSpecification<DateTime>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <DateTime>), $"Value is not between \\[{DateTimeRegexPattern}\\] and \\[{DateTimeRegexPattern}\\]") .Candidate(DateTime.Parse("2019-11-15")) .AddParameter("From", DateTime.Parse("2019-07-11")) .AddParameter("To", DateTime.Parse("2019-11-15"))); AddInvalid(DateTime.Parse("2019-11-15"), DateTime.Parse("2019-12-11"), DateTime.Parse("2019-12-15"), null) .NegationResult("NotExclusiveBetweenSpecification<DateTime>") .Result("ExclusiveBetweenSpecification<DateTime>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <DateTime>), $"Value is not between \\[{DateTimeRegexPattern}\\] and \\[{DateTimeRegexPattern}\\]") .Candidate(DateTime.Parse("2019-11-15")) .AddParameter("From", DateTime.Parse("2019-12-11")) .AddParameter("To", DateTime.Parse("2019-12-15"))); AddInvalid(cmp, notCmp1, notCmp2, null) .NegationResult("NotExclusiveBetweenSpecification<ComparableFakeType>") .Result("ExclusiveBetweenSpecification<ComparableFakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <ComparableFakeType>), "Value is not between [Fake(10)] and [Fake(15)]") .Candidate(cmp) .AddParameter("From", notCmp1) .AddParameter("To", notCmp2)); AddInvalid(cmp, notCmp3, notCmp4, null) .NegationResult("NotExclusiveBetweenSpecification<ComparableFakeType>") .Result("ExclusiveBetweenSpecification<ComparableFakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <ComparableFakeType>), "Value is not between [Fake(1)] and [Fake(3)]") .Candidate(cmp) .AddParameter("From", notCmp3) .AddParameter("To", notCmp4)); AddInvalid(cmp, notCmp5, notCmp6, null) .NegationResult("NotExclusiveBetweenSpecification<ComparableFakeType>") .Result("ExclusiveBetweenSpecification<ComparableFakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <ComparableFakeType>), "Value is not between [Fake(23)] and [Fake(30)]") .Candidate(cmp) .AddParameter("From", notCmp5) .AddParameter("To", notCmp6)); AddInvalid(cmpInter1, cmpInter2, cmpInter3, null) .NegationResult("NotExclusiveBetweenSpecification<ComparableInterFakeType>") .Result("ExclusiveBetweenSpecification<ComparableInterFakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <ComparableInterFakeType>), "Value is not between [FluentSpecification.Tests.Mocks.ComparableInterFakeType] and [FluentSpecification.Tests.Mocks.ComparableInterFakeType]") .Candidate(cmpInter1) .AddParameter("From", cmpInter2) .AddParameter("To", cmpInter3)); AddInvalid(new ComparableFakeType { Second = "null" }, notCmp1, notCmp2, null) .NegationResult("NotExclusiveBetweenSpecification<ComparableFakeType>") .Result("ExclusiveBetweenSpecification<ComparableFakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <ComparableFakeType>), "Value is not between [Fake(10)] and [Fake(15)]") .Candidate(null) .AddParameter("From", notCmp1) .AddParameter("To", notCmp2)); AddInvalid(new ComparableFakeType { Second = "null" }, null, notCmp2, null) .NegationResult("NotExclusiveBetweenSpecification<ComparableFakeType>") .Result("ExclusiveBetweenSpecification<ComparableFakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <ComparableFakeType>), "Value is not between [null] and [Fake(15)]") .Candidate(null) .AddParameter("From", null) .AddParameter("To", notCmp2)); AddInvalid(new ComparableFakeType { Second = "null" }, null, null, null) .NegationResult("NotExclusiveBetweenSpecification<ComparableFakeType>") .Result("ExclusiveBetweenSpecification<ComparableFakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <ComparableFakeType>), "Value is not between [null] and [null]") .Candidate(null) .AddParameter("From", null) .AddParameter("To", null)); AddInvalid(cmpFakeType, notCmpFakeType1, notCmpFakeType2, comparer) .NegationResult("NotExclusiveBetweenSpecification<FakeType>") .Result("ExclusiveBetweenSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <FakeType>), "Value is not between [Fake(10)] and [Fake(15)]") .Candidate(cmpFakeType) .AddParameter("From", notCmpFakeType1) .AddParameter("To", notCmpFakeType2)); AddInvalid(cmpFakeType, notCmpFakeType3, notCmpFakeType4, comparer) .NegationResult("NotExclusiveBetweenSpecification<FakeType>") .Result("ExclusiveBetweenSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <FakeType>), "Value is not between [Fake(1)] and [Fake(3)]") .Candidate(cmpFakeType) .AddParameter("From", notCmpFakeType3) .AddParameter("To", notCmpFakeType4)); AddInvalid(cmpFakeType, notCmpFakeType5, notCmpFakeType6, comparer) .NegationResult("NotExclusiveBetweenSpecification<FakeType>") .Result("ExclusiveBetweenSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <FakeType>), "Value is not between [Fake(23)] and [Fake(30)]") .Candidate(cmpFakeType) .AddParameter("From", notCmpFakeType5) .AddParameter("To", notCmpFakeType6)); AddInvalid(new FakeType { Second = "null" }, notCmpFakeType1, notCmpFakeType2, comparer) .NegationResult("NotExclusiveBetweenSpecification<FakeType>") .Result("ExclusiveBetweenSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <FakeType>), "Value is not between [Fake(10)] and [Fake(15)]") .Candidate(null) .AddParameter("From", notCmpFakeType1) .AddParameter("To", notCmpFakeType2)); AddInvalid(new FakeType { Second = "null" }, null, notCmpFakeType2, comparer) .NegationResult("NotExclusiveBetweenSpecification<FakeType>") .Result("ExclusiveBetweenSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <FakeType>), "Value is not between [null] and [Fake(15)]") .Candidate(null) .AddParameter("From", null) .AddParameter("To", notCmpFakeType2)); AddInvalid(new FakeType { Second = "null" }, null, null, comparer) .NegationResult("NotExclusiveBetweenSpecification<FakeType>") .Result("ExclusiveBetweenSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(ExclusiveBetweenSpecification <FakeType>), "Value is not between [null] and [null]") .Candidate(null) .AddParameter("From", null) .AddParameter("To", null)); }
public AllData() { int[] arr = { 1, 5, 200, 6, 100 }; var list = new List <string> { "First", "Second" }; var dict = new Dictionary <string, bool> { { "First", true }, { "Second", false } }; var ft = new FakeType { Fourth = arr }; var empty = new FakeType(); var nullFt = new FakeType { Second = "null" }; AddValid(arr, True <int>()) .Result(6, "AllSpecification<Int32[],Int32>([0](MockComplexSpecification[Int32]) And [1](MockComplexSpecification[Int32]) And [2](MockComplexSpecification[Int32]) And [3](MockComplexSpecification[Int32]) And [4](MockComplexSpecification[Int32]))"); AddValid(list, True <string>()) .Result(3, "AllSpecification<List<String>,String>([0](MockComplexSpecification[String]) And [1](MockComplexSpecification[String]))"); AddValid(dict, True <KeyValuePair <string, bool> >()) .Result(3, "AllSpecification<Dictionary<String,Boolean>,KeyValuePair<String,Boolean>>([0](MockComplexSpecification[KeyValuePair<String,Boolean>]) And [1](MockComplexSpecification[KeyValuePair<String,Boolean>]))"); AddValid(ft, True <int>()) .Result(6, "AllSpecification<FakeType,Int32>([0](MockComplexSpecification[Int32]) And [1](MockComplexSpecification[Int32]) And [2](MockComplexSpecification[Int32]) And [3](MockComplexSpecification[Int32]) And [4](MockComplexSpecification[Int32]))"); AddValid(empty, True <int>()) .Result(1, "AllSpecification<FakeType,Int32>()"); AddInvalid(nullFt, True <int>()) .Result(1, "AllSpecification<FakeType,Int32>()+Failed", c => c .FailedSpecification(typeof(AllSpecification <FakeType, int>), "Collection is null") .Candidate(null) .AddParameter("SpecificationForAll", null)); AddInvalid(arr, False <int>()) .Result(6, "AllSpecification<Int32[],Int32>([0](FailedMockComplexSpecification[Int32]) And [1](FailedMockComplexSpecification[Int32]) And [2](FailedMockComplexSpecification[Int32]) And [3](FailedMockComplexSpecification[Int32]) And [4](FailedMockComplexSpecification[Int32]))+Failed", c => { c.FailedSpecification(typeof(AllSpecification <int[], int>), "One or more elements are not specified") .Candidate(arr) .AddParameter("SpecificationForAll", null); c.FailedSpecification(typeof(MockComplexSpecification <int>), "[0] MockComplexSpecification is not satisfied") .Candidate(1) .AddParameter("Expression", null); c.FailedSpecification(typeof(MockComplexSpecification <int>), "[1] MockComplexSpecification is not satisfied") .Candidate(5) .AddParameter("Expression", null); c.FailedSpecification(typeof(MockComplexSpecification <int>), "[2] MockComplexSpecification is not satisfied") .Candidate(200) .AddParameter("Expression", null); c.FailedSpecification(typeof(MockComplexSpecification <int>), "[3] MockComplexSpecification is not satisfied") .Candidate(6) .AddParameter("Expression", null); c.FailedSpecification(typeof(MockComplexSpecification <int>), "[4] MockComplexSpecification is not satisfied") .Candidate(100) .AddParameter("Expression", null); }); AddInvalid(list, False <string>()) .Result(3, "AllSpecification<List<String>,String>([0](FailedMockComplexSpecification[String]) And [1](FailedMockComplexSpecification[String]))+Failed", c => { c.FailedSpecification(typeof(AllSpecification <List <string>, string>), "One or more elements are not specified") .Candidate(list) .AddParameter("SpecificationForAll", null); c.FailedSpecification(typeof(MockComplexSpecification <string>), "[0] MockComplexSpecification is not satisfied") .Candidate("First") .AddParameter("Expression", null); c.FailedSpecification(typeof(MockComplexSpecification <string>), "[1] MockComplexSpecification is not satisfied") .Candidate("Second") .AddParameter("Expression", null); }); AddInvalid(dict, False <KeyValuePair <string, bool> >()) .Result(3, "AllSpecification<Dictionary<String,Boolean>,KeyValuePair<String,Boolean>>([0](FailedMockComplexSpecification[KeyValuePair<String,Boolean>]) And [1](FailedMockComplexSpecification[KeyValuePair<String,Boolean>]))+Failed", c => { c.FailedSpecification( typeof(AllSpecification <Dictionary <string, bool>, KeyValuePair <string, bool> >), "One or more elements are not specified") .Candidate(dict) .AddParameter("SpecificationForAll", null); c.FailedSpecification(typeof(MockComplexSpecification <KeyValuePair <string, bool> >), "[0] MockComplexSpecification is not satisfied") .Candidate(new KeyValuePair <string, bool>("First", true)) .AddParameter("Expression", null); c.FailedSpecification(typeof(MockComplexSpecification <KeyValuePair <string, bool> >), "[1] MockComplexSpecification is not satisfied") .Candidate(new KeyValuePair <string, bool>("Second", false)) .AddParameter("Expression", null); }); AddInvalid(ft, False <int>()) .Result(6, "AllSpecification<FakeType,Int32>([0](FailedMockComplexSpecification[Int32]) And [1](FailedMockComplexSpecification[Int32]) And [2](FailedMockComplexSpecification[Int32]) And [3](FailedMockComplexSpecification[Int32]) And [4](FailedMockComplexSpecification[Int32]))+Failed", c => { c.FailedSpecification(typeof(AllSpecification <FakeType, int>), "One or more elements are not specified") .Candidate(arr) .AddParameter("SpecificationForAll", null); c.FailedSpecification(typeof(MockComplexSpecification <int>), "[0] MockComplexSpecification is not satisfied") .Candidate(1) .AddParameter("Expression", null); c.FailedSpecification(typeof(MockComplexSpecification <int>), "[1] MockComplexSpecification is not satisfied") .Candidate(5) .AddParameter("Expression", null); c.FailedSpecification(typeof(MockComplexSpecification <int>), "[2] MockComplexSpecification is not satisfied") .Candidate(200) .AddParameter("Expression", null); c.FailedSpecification(typeof(MockComplexSpecification <int>), "[3] MockComplexSpecification is not satisfied") .Candidate(6) .AddParameter("Expression", null); c.FailedSpecification(typeof(MockComplexSpecification <int>), "[4] MockComplexSpecification is not satisfied") .Candidate(100) .AddParameter("Expression", null); }); AddInvalid(arr, FewInt()) .Result(6, "AllSpecification<Int32[],Int32>([0](MockComplexSpecification[Int32]) And [1](MockComplexSpecification[Int32]) And [2](FailedMockComplexSpecification[Int32]) And [3](MockComplexSpecification[Int32]) And [4](FailedMockComplexSpecification[Int32]))+Failed", c => { c.FailedSpecification(typeof(AllSpecification <int[], int>), "One or more elements are not specified") .Candidate(arr) .AddParameter("SpecificationForAll", null); c.FailedSpecification(typeof(MockComplexSpecification <int>), "[2] MockComplexSpecification is not satisfied") .Candidate(200) .AddParameter("Expression", null); c.FailedSpecification(typeof(MockComplexSpecification <int>), "[4] MockComplexSpecification is not satisfied") .Candidate(100) .AddParameter("Expression", null); }); AddInvalid(list, FewString()) .Result(3, "AllSpecification<List<String>,String>([0](MockComplexSpecification[String]) And [1](FailedMockComplexSpecification[String]))+Failed", c => { c.FailedSpecification(typeof(AllSpecification <List <string>, string>), "One or more elements are not specified") .Candidate(list) .AddParameter("SpecificationForAll", null); c.FailedSpecification(typeof(MockComplexSpecification <string>), "[1] MockComplexSpecification is not satisfied") .Candidate("Second") .AddParameter("Expression", null); }); AddInvalid(dict, FewPair()) .Result(3, "AllSpecification<Dictionary<String,Boolean>,KeyValuePair<String,Boolean>>([0](MockComplexSpecification[KeyValuePair<String,Boolean>]) And [1](FailedMockComplexSpecification[KeyValuePair<String,Boolean>]))+Failed", c => { c.FailedSpecification( typeof(AllSpecification <Dictionary <string, bool>, KeyValuePair <string, bool> >), "One or more elements are not specified") .Candidate(dict) .AddParameter("SpecificationForAll", null); c.FailedSpecification(typeof(MockComplexSpecification <KeyValuePair <string, bool> >), "[1] MockComplexSpecification is not satisfied") .Candidate(new KeyValuePair <string, bool>("Second", false)) .AddParameter("Expression", null); }); AddInvalid(ft, FewInt()) .Result(6, "AllSpecification<FakeType,Int32>([0](MockComplexSpecification[Int32]) And [1](MockComplexSpecification[Int32]) And [2](FailedMockComplexSpecification[Int32]) And [3](MockComplexSpecification[Int32]) And [4](FailedMockComplexSpecification[Int32]))+Failed", c => { c.FailedSpecification(typeof(AllSpecification <FakeType, int>), "One or more elements are not specified") .Candidate(ft) .AddParameter("SpecificationForAll", null); c.FailedSpecification(typeof(MockComplexSpecification <int>), "[2] MockComplexSpecification is not satisfied") .Candidate(200) .AddParameter("Expression", null); c.FailedSpecification(typeof(MockComplexSpecification <int>), "[4] MockComplexSpecification is not satisfied") .Candidate(100) .AddParameter("Expression", null); }); }
public LengthBetweenData() { int[] emptyArr = new int[0], arr = { 1, 2, 3 }; var list = new List <int> { 1, 2, 3 }; var dict = new Dictionary <int, bool> { { 1, false }, { 2, true } }; var ft = new FakeType { Fourth = new[] { 1, 2, 3 } }; var ift = new InterFakeType(); AddValid("", 0, 0) .Result("LengthBetweenSpecification<String>") .NegationResult("NotLengthBetweenSpecification<String>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <string>), "Object length is between [0] and [0]") .Candidate("") .AddParameter("MinLength", 0) .AddParameter("MaxLength", 0)); AddValid("test", 1, 4) .Result("LengthBetweenSpecification<String>") .NegationResult("NotLengthBetweenSpecification<String>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <string>), "Object length is between [1] and [4]") .Candidate("test") .AddParameter("MinLength", 1) .AddParameter("MaxLength", 4)); AddValid(emptyArr, 0, 0) .Result("LengthBetweenSpecification<Int32[]>") .NegationResult("NotLengthBetweenSpecification<Int32[]>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <int[]>), "Object length is between [0] and [0]") .Candidate(emptyArr) .AddParameter("MinLength", 0) .AddParameter("MaxLength", 0)); AddValid(arr, 2, 3) .Result("LengthBetweenSpecification<Int32[]>") .NegationResult("NotLengthBetweenSpecification<Int32[]>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <int[]>), "Object length is between [2] and [3]") .Candidate(arr) .AddParameter("MinLength", 2) .AddParameter("MaxLength", 3)); AddValid(list, -1, 10) .Result("LengthBetweenSpecification<List<Int32>>") .NegationResult("NotLengthBetweenSpecification<List<Int32>>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <List <int> >), "Object length is between [-1] and [10]") .Candidate(list) .AddParameter("MinLength", -1) .AddParameter("MaxLength", 10)); AddValid(dict, 0, 5) .Result("LengthBetweenSpecification<Dictionary<Int32,Boolean>>") .NegationResult("NotLengthBetweenSpecification<Dictionary<Int32,Boolean>>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <Dictionary <int, bool> >), "Object length is between [0] and [5]") .Candidate(dict) .AddParameter("MinLength", 0) .AddParameter("MaxLength", 5)); AddValid(ft, 0, 3) .Result("LengthBetweenSpecification<FakeType>") .NegationResult("NotLengthBetweenSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <FakeType>), "Object length is between [0] and [3]") .Candidate(ft) .AddParameter("MinLength", 0) .AddParameter("MaxLength", 3)); AddValid(ift, 1, 1) .Result("LengthBetweenSpecification<InterFakeType>") .NegationResult("NotLengthBetweenSpecification<InterFakeType>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <InterFakeType>), "Object length is between [1] and [1]") .Candidate(ift) .AddParameter("MinLength", 1) .AddParameter("MaxLength", 1)); AddInvalid("", 1, 10) .NegationResult("NotLengthBetweenSpecification<String>") .Result("LengthBetweenSpecification<String>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <string>), "Object length is not between [1] and [10]") .Candidate("") .AddParameter("MinLength", 1) .AddParameter("MaxLength", 10)); AddInvalid("test", 10, 20) .NegationResult("NotLengthBetweenSpecification<String>") .Result("LengthBetweenSpecification<String>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <string>), "Object length is not between [10] and [20]") .Candidate("test") .AddParameter("MinLength", 10) .AddParameter("MaxLength", 20)); AddInvalid(emptyArr, 1, 2) .NegationResult("NotLengthBetweenSpecification<Int32[]>") .Result("LengthBetweenSpecification<Int32[]>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <int[]>), "Object length is not between [1] and [2]") .Candidate(emptyArr) .AddParameter("MinLength", 1) .AddParameter("MaxLength", 2)); AddInvalid(arr, -5, -1) .NegationResult("NotLengthBetweenSpecification<Int32[]>") .Result("LengthBetweenSpecification<Int32[]>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <int[]>), "Object length is not between [-5] and [-1]") .Candidate(arr) .AddParameter("MinLength", -5) .AddParameter("MaxLength", -1)); AddInvalid(list, 0, 1) .NegationResult("NotLengthBetweenSpecification<List<Int32>>") .Result("LengthBetweenSpecification<List<Int32>>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <List <int> >), "Object length is not between [0] and [1]") .Candidate(list) .AddParameter("MinLength", 0) .AddParameter("MaxLength", 1)); AddInvalid(dict, 0, 1) .NegationResult("NotLengthBetweenSpecification<Dictionary<Int32,Boolean>>") .Result("LengthBetweenSpecification<Dictionary<Int32,Boolean>>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <Dictionary <int, bool> >), "Object length is not between [0] and [1]") .Candidate(dict) .AddParameter("MinLength", 0) .AddParameter("MaxLength", 1)); AddInvalid(ft, 4, 6) .NegationResult("NotLengthBetweenSpecification<FakeType>") .Result("LengthBetweenSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <FakeType>), "Object length is not between [4] and [6]") .Candidate(ft) .AddParameter("MinLength", 4) .AddParameter("MaxLength", 6)); AddInvalid(ift, 4, 6) .NegationResult("NotLengthBetweenSpecification<InterFakeType>") .Result("LengthBetweenSpecification<InterFakeType>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <InterFakeType>), "Object length is not between [4] and [6]") .Candidate(ift) .AddParameter("MinLength", 4) .AddParameter("MaxLength", 6)); AddInvalid("null", 0, 1) .NegationResult("NotLengthBetweenSpecification<String>") .Result("LengthBetweenSpecification<String>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <string>), "Object length is not between [0] and [1]") .Candidate(null) .AddParameter("MinLength", 0) .AddParameter("MaxLength", 1)); AddInvalid(new FakeType { Second = "null" }, 0, 0) .NegationResult("NotLengthBetweenSpecification<FakeType>") .Result("LengthBetweenSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(LengthBetweenSpecification <FakeType>), "Object length is not between [0] and [0]") .Candidate(null) .AddParameter("MinLength", 0) .AddParameter("MaxLength", 0)); }
public FakeTarget(FakeType type) { Type = type; }
public LessThanData() { var comparer = new FakeTypeComparer(); var intComparer = new FakeIntComparer(); ComparableFakeType cmp = new ComparableFakeType { First = 116 }, cmp2 = new ComparableFakeType { First = 154 }; ComparableInterFakeType cmpInter1 = new ComparableInterFakeType(), cmpInter2 = new ComparableInterFakeType(), cmpInter3 = new ComparableInterFakeType { Third = true }; FakeType cmpFakeType = new FakeType { First = 116 }, cmpFakeType2 = new FakeType { First = 154 }; AddValid(1, 5, null) .Result("LessThanSpecification<Int32>") .NegationResult("NotLessThanSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <int>), "Object is lower than [5]") .Candidate(1) .AddParameter("LessThan", 5)); AddValid(-1, 1, null) .Result("LessThanSpecification<Int32>") .NegationResult("NotLessThanSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <int>), "Object is lower than [1]") .Candidate(-1) .AddParameter("LessThan", 1)); AddValid(-9, -1, intComparer) .Result("LessThanSpecification<Int32>") .NegationResult("NotLessThanSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <int>), "Object is lower than [-1]") .Candidate(-9) .AddParameter("LessThan", -1)); AddValid(5.74, 5.75, null) .Result("LessThanSpecification<Double>") .NegationResult("NotLessThanSpecification<Double>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <double>), "Object is lower than [5.75]") .Candidate(5.74) .AddParameter("LessThan", 5.75)); AddValid(-2.5, 0.0, null) .Result("LessThanSpecification<Double>") .NegationResult("NotLessThanSpecification<Double>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <double>), "Object is lower than [0]") .Candidate(-2.5) .AddParameter("LessThan", 0.0)); AddValid(-5.75, -5.74, null) .Result("LessThanSpecification<Double>") .NegationResult("NotLessThanSpecification<Double>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <double>), "Object is lower than [-5.74]") .Candidate(-5.75) .AddParameter("LessThan", -5.74)); AddValid(false, true, null) .Result("LessThanSpecification<Boolean>") .NegationResult("NotLessThanSpecification<Boolean>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <bool>), "Object is lower than [True]") .Candidate(false) .AddParameter("LessThan", true)); AddValid("123", "124", null) .Result("LessThanSpecification<String>") .NegationResult("NotLessThanSpecification<String>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <string>), "Object is lower than [124]") .Candidate("123") .AddParameter("LessThan", "124")); AddValid("123", "1234", null) .Result("LessThanSpecification<String>") .NegationResult("NotLessThanSpecification<String>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <string>), "Object is lower than [1234]") .Candidate("123") .AddParameter("LessThan", "1234")); AddValid("null", "test", null) .Result("LessThanSpecification<String>") .NegationResult("NotLessThanSpecification<String>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <string>), "Object is lower than [test]") .Candidate(null) .AddParameter("LessThan", "test")); AddValid(DateTime.Parse("2018-01-15"), DateTime.Parse("2019-07-11"), null) .Result("LessThanSpecification<DateTime>") .NegationResult("NotLessThanSpecification<DateTime>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <DateTime>), $"Object is lower than \\[{DateTimeRegexPattern}\\]") .Candidate(DateTime.Parse("2018-01-15")) .AddParameter("LessThan", DateTime.Parse("2019-07-11"))); AddValid(DateTime.Parse("2019-07-01"), DateTime.Parse("2019-07-11"), null) .Result("LessThanSpecification<DateTime>") .NegationResult("NotLessThanSpecification<DateTime>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <DateTime>), $"Object is lower than \\[{DateTimeRegexPattern}\\]") .Candidate(DateTime.Parse("2019-07-01")) .AddParameter("LessThan", DateTime.Parse("2019-07-11"))); AddValid(cmp, cmp2, null) .Result("LessThanSpecification<ComparableFakeType>") .NegationResult("NotLessThanSpecification<ComparableFakeType>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <ComparableFakeType>), "Object is lower than [Fake(154)]") .Candidate(cmp) .AddParameter("LessThan", cmp2)); AddValid(new ComparableFakeType { Second = "null" }, new ComparableFakeType(), null) .Result("LessThanSpecification<ComparableFakeType>") .NegationResult("NotLessThanSpecification<ComparableFakeType>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <ComparableFakeType>), "Object is lower than [Fake(0)]") .Candidate(null) .AddParameter("LessThan", new ComparableFakeType())); AddValid(cmpInter1, cmpInter3, null) .Result("LessThanSpecification<ComparableInterFakeType>") .NegationResult("NotLessThanSpecification<ComparableInterFakeType>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <ComparableInterFakeType>), "Object is lower than [FluentSpecification.Tests.Mocks.ComparableInterFakeType]") .Candidate(cmpInter1) .AddParameter("LessThan", cmpInter3)); AddValid(cmpFakeType, cmpFakeType2, comparer) .Result("LessThanSpecification<FakeType>") .NegationResult("NotLessThanSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <FakeType>), "Object is lower than [Fake(154)]") .Candidate(cmpFakeType) .AddParameter("LessThan", cmpFakeType2)); AddValid(new FakeType { Second = "null" }, new FakeType(), comparer) .Result("LessThanSpecification<FakeType>") .NegationResult("NotLessThanSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <FakeType>), "Object is lower than [Fake(0)]") .Candidate(null) .AddParameter("LessThan", new FakeType())); ComparableFakeType notCmp1 = new ComparableFakeType { First = 11 }, notCmp2 = new ComparableFakeType { First = 10 }, notCmp3 = new ComparableFakeType { First = 10 }; FakeType notCmpFakeType1 = new FakeType { First = 11 }, notCmpFakeType2 = new FakeType { First = 10 }, notCmpFakeType3 = new FakeType { First = 10 }; AddInvalid(2, 2, null) .NegationResult("NotLessThanSpecification<Int32>") .Result("LessThanSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <int>), "Object is greater than or equal to [2]") .Candidate(2) .AddParameter("LessThan", 2)); AddInvalid(-2, -2, null) .NegationResult("NotLessThanSpecification<Int32>") .Result("LessThanSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <int>), "Object is greater than or equal to [-2]") .Candidate(-2) .AddParameter("LessThan", -2)); AddInvalid(1, -1, null) .NegationResult("NotLessThanSpecification<Int32>") .Result("LessThanSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <int>), "Object is greater than or equal to [-1]") .Candidate(1) .AddParameter("LessThan", -1)); AddInvalid(5, 3, null) .NegationResult("NotLessThanSpecification<Int32>") .Result("LessThanSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <int>), "Object is greater than or equal to [3]") .Candidate(5) .AddParameter("LessThan", 3)); AddInvalid(-1, -10, intComparer) .NegationResult("NotLessThanSpecification<Int32>") .Result("LessThanSpecification<Int32>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <int>), "Object is greater than or equal to [-10]") .Candidate(-1) .AddParameter("LessThan", -10)); AddInvalid(3.5, 3.5, null) .NegationResult("NotLessThanSpecification<Double>") .Result("LessThanSpecification<Double>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <double>), "Object is greater than or equal to [3.5]") .Candidate(3.5) .AddParameter("LessThan", 3.5)); AddInvalid(-3.5, -3.5, null) .NegationResult("NotLessThanSpecification<Double>") .Result("LessThanSpecification<Double>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <double>), "Object is greater than or equal to [-3.5]") .Candidate(-3.5) .AddParameter("LessThan", -3.5)); AddInvalid(5.74, 3.74, null) .NegationResult("NotLessThanSpecification<Double>") .Result("LessThanSpecification<Double>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <double>), "Object is greater than or equal to [3.74]") .Candidate(5.74) .AddParameter("LessThan", 3.74)); AddInvalid(-3.74, -5.74, null) .NegationResult("NotLessThanSpecification<Double>") .Result("LessThanSpecification<Double>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <double>), "Object is greater than or equal to [-5.74]") .Candidate(-3.74) .AddParameter("LessThan", -5.74)); AddInvalid(5.74, -3.74, null) .NegationResult("NotLessThanSpecification<Double>") .Result("LessThanSpecification<Double>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <double>), "Object is greater than or equal to [-3.74]") .Candidate(5.74) .AddParameter("LessThan", -3.74)); AddInvalid(true, false, null) .NegationResult("NotLessThanSpecification<Boolean>") .Result("LessThanSpecification<Boolean>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <bool>), "Object is greater than or equal to [False]") .Candidate(true) .AddParameter("LessThan", false)); AddInvalid(false, false, null) .NegationResult("NotLessThanSpecification<Boolean>") .Result("LessThanSpecification<Boolean>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <bool>), "Object is greater than or equal to [False]") .Candidate(false) .AddParameter("LessThan", false)); AddInvalid("123", "122", null) .NegationResult("NotLessThanSpecification<String>") .Result("LessThanSpecification<String>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <string>), "Object is greater than or equal to [122]") .Candidate("123") .AddParameter("LessThan", "122")); AddInvalid("1234", "123", null) .NegationResult("NotLessThanSpecification<String>") .Result("LessThanSpecification<String>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <string>), "Object is greater than or equal to [123]") .Candidate("1234") .AddParameter("LessThan", "123")); AddInvalid("123", "123", null) .NegationResult("NotLessThanSpecification<String>") .Result("LessThanSpecification<String>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <string>), "Object is greater than or equal to [123]") .Candidate("123") .AddParameter("LessThan", "123")); AddInvalid("test1", null, null) .NegationResult("NotLessThanSpecification<String>") .Result("LessThanSpecification<String>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <string>), "Object is greater than or equal to [null]") .Candidate("test1") .AddParameter("LessThan", null)); AddInvalid("null", null, null) .NegationResult("NotLessThanSpecification<String>") .Result("LessThanSpecification<String>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <string>), "Object is greater than or equal to [null]") .Candidate(null) .AddParameter("LessThan", null)); AddInvalid(DateTime.Parse("2019-11-15"), DateTime.Parse("2019-07-11"), null) .NegationResult("NotLessThanSpecification<DateTime>") .Result("LessThanSpecification<DateTime>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <DateTime>), $"Object is greater than or equal to \\[{DateTimeRegexPattern}\\]") .Candidate(DateTime.Parse("2019-11-15")) .AddParameter("LessThan", DateTime.Parse("2019-07-11"))); AddInvalid(DateTime.Parse("2019-07-11"), DateTime.Parse("2019-07-11"), null) .NegationResult("NotLessThanSpecification<DateTime>") .Result("LessThanSpecification<DateTime>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <DateTime>), $"Object is greater than or equal to \\[{DateTimeRegexPattern}\\]") .Candidate(DateTime.Parse("2019-07-11")) .AddParameter("LessThan", DateTime.Parse("2019-07-11"))); AddInvalid(notCmp1, notCmp2, null) .NegationResult("NotLessThanSpecification<ComparableFakeType>") .Result("LessThanSpecification<ComparableFakeType>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <ComparableFakeType>), "Object is greater than or equal to [Fake(10)]") .Candidate(notCmp1) .AddParameter("LessThan", notCmp2)); AddInvalid(notCmp2, notCmp3, null) .NegationResult("NotLessThanSpecification<ComparableFakeType>") .Result("LessThanSpecification<ComparableFakeType>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <ComparableFakeType>), "Object is greater than or equal to [Fake(10)]") .Candidate(notCmp2) .AddParameter("LessThan", notCmp3)); AddInvalid(new ComparableFakeType { Second = "null" }, null, null) .NegationResult("NotLessThanSpecification<ComparableFakeType>") .Result("LessThanSpecification<ComparableFakeType>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <ComparableFakeType>), "Object is greater than or equal to [null]") .Candidate(null) .AddParameter("LessThan", null)); AddInvalid(cmpInter1, cmpInter2, null) .NegationResult("NotLessThanSpecification<ComparableInterFakeType>") .Result("LessThanSpecification<ComparableInterFakeType>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <ComparableInterFakeType>), "Object is greater than or equal to [FluentSpecification.Tests.Mocks.ComparableInterFakeType]") .Candidate(cmpInter1) .AddParameter("LessThan", cmpInter2)); AddInvalid(notCmpFakeType1, notCmpFakeType2, comparer) .NegationResult("NotLessThanSpecification<FakeType>") .Result("LessThanSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <FakeType>), "Object is greater than or equal to [Fake(10)]") .Candidate(notCmpFakeType1) .AddParameter("LessThan", notCmpFakeType2)); AddInvalid(notCmpFakeType2, notCmpFakeType3, comparer) .NegationResult("NotLessThanSpecification<FakeType>") .Result("LessThanSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <FakeType>), "Object is greater than or equal to [Fake(10)]") .Candidate(notCmpFakeType2) .AddParameter("LessThan", notCmpFakeType3)); AddInvalid(new FakeType { Second = "null" }, null, comparer) .NegationResult("NotLessThanSpecification<FakeType>") .Result("LessThanSpecification<FakeType>+Failed", c => c .FailedSpecification(typeof(LessThanSpecification <FakeType>), "Object is greater than or equal to [null]") .Candidate(null) .AddParameter("LessThan", null)); }
/// <summary> /// Creates a new ballot for a voter. /// </summary> /// <param name="vota">Vota the voter wishes to cast for each option.</param> /// <param name="parameters">Cryptographic parameters.</param> /// <param name="publicKey">Public key of voting authorities.</param> /// <param name="progress">Report progress up.</param> /// <param name="fakeType">What fake to create?</param> public Ballot(IEnumerable<int> vota, BaseParameters parameters, Question questionParameters, BigInt publicKey, FakeType fakeType) { if (vota == null) throw new ArgumentNullException("vota"); if (parameters == null) throw new ArgumentNullException("parameters"); if (publicKey == null) throw new ArgumentNullException("publicKey"); if (vota.Count() != questionParameters.Options.Count()) throw new ArgumentException("Bad vota."); if (!vota.All(votum => votum.InRange(0, 1))) throw new ArgumentException("Bad vota."); if (vota.Sum() != questionParameters.MaxVota) throw new ArgumentException("Bad vota."); Votes = new List<Vote>(); BigInt nonceSum = new BigInt(0); Vote voteSum = null; List<Tuple<int, BigInt, BaseParameters, BigInt>> voteWorkList = new List<Tuple<int, BigInt, BaseParameters, BigInt>>(); foreach (int votum in vota) { BigInt nonce = parameters.Random(); nonceSum += nonce; voteWorkList.Add(new Tuple<int, BigInt, BaseParameters, BigInt>(votum, nonce, parameters, publicKey)); } List<Vote> voteList = Parallel .Work<Tuple<int, BigInt, BaseParameters, BigInt>, Vote>(CreateVote, voteWorkList, null); foreach (Vote vote in voteList) { voteSum = voteSum == null ? vote : voteSum + vote; Votes.Add(vote); } SumProves = new List<Proof>(); for (int proofIndex = 0; proofIndex < parameters.ProofCount; proofIndex++) { SumProves.Add(new Proof(nonceSum * 12, voteSum, publicKey, parameters, fakeType)); } }
public FakeCommonTypeBuilder AddProperty(string name, FakeType propertyType, PropertyMethods propertyMethods, params FakeAttribute[] propertyFakeAttributes) { properties.Add(new FakeProperty(name, propertyType, propertyMethods, propertyFakeAttributes)); return(this); }
private static Type CreateReflectionType(FakeType fakeType) { return(fakeType.Type ?? CreateReflectionType(fakeType.FullName, fakeType.BaseType)); }