public void ComplexTypeConvention_Unsuccessful_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType<Z3.ObjectTheorem.EF.Metamodel.Field>(); objectTheorem.RegisterSuperType<Z3.ObjectTheorem.EF.Metamodel.Type>(); var addressType = objectTheorem.CreateInstance<ReferenceType>("AddressType"); var nameField = objectTheorem.CreateInstance<ValueField>("NameField"); // Act EFConstraints.AddComplexTypeRuleConstraints(objectTheorem.ConstraintBuilder); objectTheorem.ConstraintBuilder .Assert(() => !addressType.HasCollectionFields && addressType.HasSingleFields) .Assert(() => addressType.ValueFields == new[] { nameField }); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => addressType.HasComplexTypeAttribute == true); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Unsatisfiable, solved.Status); var assume1Result = solved.IsAssumptionWrong(assume1); Assert.IsTrue(assume1Result); objectTheorem.ConstraintBuilder.RemoveAssumption(assume1); solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); bool HasComplexTypeAttribute = solved.GetValue(addressType, i => i.HasComplexTypeAttribute); Assert.IsFalse(HasComplexTypeAttribute); }
public void IdKeyDiscoveryConvention_And_KeyAttributeConvention_Unsuccessful_Unsatisfiable_() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType<Z3.ObjectTheorem.EF.Metamodel.Type>(); var employeeType = objectTheorem.CreateInstance<ReferenceType>("EmployeeType"); objectTheorem.RegisterSuperType<Field>(); objectTheorem.SetPossibleStringValues("Id", "Title", "Name", "Income", "ID", "EmployeeTypeId", "EmployeeTypeID"); var titleField = objectTheorem.CreateInstance<ValueField>("TitleField"); var nameField = objectTheorem.CreateInstance<ValueField>("NameField"); var incomeField = objectTheorem.CreateInstance<ValueField>("IncomeField"); // Act EFConstraints.AddPrimayKeyRuleConstraints(objectTheorem.ConstraintBuilder); objectTheorem.ConstraintBuilder .Assert(() => employeeType.IsEntity == true) .Assert(() => employeeType.ValueFields == new[] { titleField, nameField, incomeField }) .Assert(() => titleField.Name == "Title") .Assert(() => titleField.Owner == employeeType) .Assert(() => nameField.Name == "Name") .Assert(() => nameField.Owner == employeeType) .Assert(() => incomeField.Name == "Income") .Assert(() => incomeField.Owner == employeeType); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => titleField.HasKeyAttribute == false); var assume2 = objectTheorem.ConstraintBuilder.Assume(() => nameField.HasKeyAttribute == false); var assume3 = objectTheorem.ConstraintBuilder.Assume(() => incomeField.HasKeyAttribute == false); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Unsatisfiable, solved.Status); var assume1Result = solved.IsAssumptionWrong(assume1); Assert.IsTrue(assume1Result); objectTheorem.ConstraintBuilder.RemoveAssumption(assume1); solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); bool HasKeyAttribute1 = solved.GetValue(titleField, i => i.HasKeyAttribute); bool HasKeyAttribute2 = solved.GetValue(nameField, i => i.HasKeyAttribute); bool HasKeyAttribute3 = solved.GetValue(incomeField, i => i.HasKeyAttribute); Assert.IsTrue(HasKeyAttribute1); Assert.IsFalse(HasKeyAttribute2); Assert.IsFalse(HasKeyAttribute3); bool IsPrimaryKey1 = solved.GetValue(titleField, i => i.IsPrimaryKey); bool IsPrimaryKey2 = solved.GetValue(nameField, i => i.IsPrimaryKey); bool IsPrimaryKey3 = solved.GetValue(incomeField, i => i.IsPrimaryKey); Assert.IsTrue(IsPrimaryKey1); Assert.IsFalse(IsPrimaryKey2); Assert.IsFalse(IsPrimaryKey3); }
public void ForeignKeyTypeMatchRule_Unsuccessful_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType <Type>(); objectTheorem.RegisterSuperType <Field>(); objectTheorem.RegisterSuperType <ReferenceField>(); var productType = objectTheorem.CreateInstance <ReferenceType>("ProductType"); var categoryType = objectTheorem.CreateInstance <ReferenceType>("CategoryType"); var stringType = objectTheorem.CreateInstance <ValueType>("StringType"); var guidType = objectTheorem.CreateInstance <ValueType>("GuidType"); var categoryField = objectTheorem.CreateInstance <SingleField>("CategoryField"); var categoryIdField = objectTheorem.CreateInstance <ValueField>("CategoryIdField"); var idField = objectTheorem.CreateInstance <ValueField>("IdField"); objectTheorem.SetPossibleStringValues("ID", "Id", "CategoryId"); // Act objectTheorem.ConstraintBuilder .Assert(() => categoryIdField.Type == idField.Type) .Assert(() => productType.SingleFields == new[] { categoryField }) .Assert(() => categoryField.Owner == productType) .Assert(() => categoryField.Type == categoryType) .Assert(() => productType.ValueFields == new[] { categoryIdField }) .Assert(() => categoryIdField.Owner == productType) .Assert(() => categoryIdField.Name == "CategoryId") .Assert(() => categoryType.ValueFields == new[] { idField }) .Assert(() => idField.Owner == categoryType) .Assert(() => idField.Name == "Id") .Assert(() => idField.Type == guidType); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => categoryIdField.Type == stringType); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Unsatisfiable, solved.Status); var assume1Result = solved.IsAssumptionWrong(assume1); Assert.IsTrue(assume1Result); objectTheorem.ConstraintBuilder.RemoveAssumption(assume1); solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); ValueType Type1 = solved.GetValue(categoryIdField, f => f.Type); Assert.AreEqual(guidType, Type1); }
public void ForeignKeyTypeMatchRule_Unsuccessful_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType<Type>(); objectTheorem.RegisterSuperType<Field>(); objectTheorem.RegisterSuperType<ReferenceField>(); var productType = objectTheorem.CreateInstance<ReferenceType>("ProductType"); var categoryType = objectTheorem.CreateInstance<ReferenceType>("CategoryType"); var stringType = objectTheorem.CreateInstance<ValueType>("StringType"); var guidType = objectTheorem.CreateInstance<ValueType>("GuidType"); var categoryField = objectTheorem.CreateInstance<SingleField>("CategoryField"); var categoryIdField = objectTheorem.CreateInstance<ValueField>("CategoryIdField"); var idField = objectTheorem.CreateInstance<ValueField>("IdField"); objectTheorem.SetPossibleStringValues("ID", "Id", "CategoryId"); // Act objectTheorem.ConstraintBuilder .Assert(() => categoryIdField.Type == idField.Type) .Assert(() => productType.SingleFields == new[] { categoryField }) .Assert(() => categoryField.Owner == productType) .Assert(() => categoryField.Type == categoryType) .Assert(() => productType.ValueFields == new[] { categoryIdField }) .Assert(() => categoryIdField.Owner == productType) .Assert(() => categoryIdField.Name == "CategoryId") .Assert(() => categoryType.ValueFields == new[] { idField }) .Assert(() => idField.Owner == categoryType) .Assert(() => idField.Name == "Id") .Assert(() => idField.Type == guidType); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => categoryIdField.Type == stringType); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Unsatisfiable, solved.Status); var assume1Result = solved.IsAssumptionWrong(assume1); Assert.IsTrue(assume1Result); objectTheorem.ConstraintBuilder.RemoveAssumption(assume1); solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); ValueType Type1 = solved.GetValue(categoryIdField, f => f.Type); Assert.AreEqual(guidType, Type1); }
public void IndexRule_Successful_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType<Type>(); objectTheorem.RegisterSuperType<Field>(); var valueField1 = objectTheorem.CreateInstance<ValueField>("ValueField1"); var stringType = objectTheorem.CreateInstance<ValueType>("StringType"); // Act EFConstraints.AddIndexRuleConstraints(objectTheorem.ConstraintBuilder, stringType); objectTheorem.ConstraintBuilder .Assert(() => valueField1.Type == stringType); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasIndexAttribute == true); var assume2 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasMaxLengthAttribute == true); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); }
public void ComplexTypeConvention_Successful_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType <Z3.ObjectTheorem.EF.Metamodel.Field>(); objectTheorem.RegisterSuperType <Z3.ObjectTheorem.EF.Metamodel.Type>(); var addressType = objectTheorem.CreateInstance <ReferenceType>("AddressType"); var nameField = objectTheorem.CreateInstance <ValueField>("NameField"); // Act EFConstraints.AddComplexTypeRuleConstraints(objectTheorem.ConstraintBuilder); objectTheorem.ConstraintBuilder .Assert(() => !addressType.HasCollectionFields && !addressType.HasSingleFields) .Assert(() => addressType.ValueFields == new[] { nameField }); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => addressType.HasComplexTypeAttribute == true); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); bool HasComplexTypeAttribute = solved.GetValue(addressType, i => i.HasComplexTypeAttribute); Assert.IsTrue(HasComplexTypeAttribute); }
public void SimpleModel_OutsideConstant_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var outsideBoolConstant = true; var classAInstance = objectTheorem.CreateInstance <ClassA>("ClassAInstance"); var classBInstance = objectTheorem.CreateInstance <ClassB>("ClassBInstance"); // Act objectTheorem.ConstraintBuilder .AssertAll <ClassA, ClassB>((a, b) => a.IsValidA == b.IsValidB) .Assert(() => classAInstance.IsValidA == outsideBoolConstant); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); bool isValidA = solved.GetValue(classAInstance, i => i.IsValidA); bool isValidB = solved.GetValue(classBInstance, i => i.IsValidB); Assert.IsTrue(isValidA); Assert.IsTrue(isValidB); }
public void EnumValuesFromOutside_ShouldBe_Satisfiable2() { // Arrange var objectTheorem = new ObjectTheoremContext(); var classAInstance1 = objectTheorem.CreateInstance <ClassA>("ClassAInstance"); var classAInstance2 = objectTheorem.CreateInstance <ClassA>("ClassBInstance"); // Act var color = Colors.Black; objectTheorem.ConstraintBuilder .Assert(() => classAInstance1.Color != classAInstance2.Color) .Assert(() => classAInstance1.Color == color); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Colors color1 = solved.GetValue(classAInstance1, i => i.Color); Colors color2 = solved.GetValue(classAInstance2, i => i.Color); Assert.IsTrue(color1 != color2); Assert.AreEqual(color, color1); }
public void WithAnyAndAll_TwoItemArray_ShouldBe_Unsatisfiable2() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance <Category>("TypeInstance1"); var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1"); var fieldInstance2 = objectTheorem.CreateInstance <Product>("FieldInstance2"); // Act objectTheorem.ConstraintBuilder .AssertAll <Category>(t => t.Products.Any(f1 => f1.IsPremiumOnly == true && t.Products.All(f2 => f2 == f1 || f2.IsPremiumOnly == false))) .Assert(() => typeInstance1.Products == new[] { fieldInstance1, fieldInstance2 }) .Assert(() => fieldInstance1.Category == typeInstance1) .Assert(() => fieldInstance2.Category == typeInstance1) .Assert(() => fieldInstance1.IsPremiumOnly == false) .Assert(() => fieldInstance2.IsPremiumOnly == false); // Assert var solved = objectTheorem.Solve(); Assert.IsNull(solved); }
public void ForeignKeyDiscoveryConvention_Successful_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType<Type>(); objectTheorem.RegisterSuperType<Field>(); objectTheorem.RegisterSuperType<ReferenceField>(); var nullType = objectTheorem.CreateInstance<ReferenceType>("NullType"); var categoryType = objectTheorem.CreateInstance<ReferenceType>("CategoryType"); var categoryIdField = objectTheorem.CreateInstance<ValueField>("CategoryIdField"); var productType = objectTheorem.CreateInstance<ReferenceType>("ProductType"); var productIdField = objectTheorem.CreateInstance<ValueField>("ProductIdField"); var productCategoryIdField = objectTheorem.CreateInstance<ValueField>("productCategoryIdField"); var productCategoryField = objectTheorem.CreateInstance<SingleField>("productCategoryField"); var stringType = objectTheorem.CreateInstance<ValueType>("StringType"); var numberType = objectTheorem.CreateInstance<ValueType>("NumberType"); var guidType = objectTheorem.CreateInstance<ValueType>("GuidType"); objectTheorem.SetPossibleStringValues("CatId", "ProdId", "CategoryId", "Category", "-"); // Act objectTheorem.ConstraintBuilder .AssertAll<SingleField>(sf => sf.Owner.ValueFields.Any(vf => vf.Name == sf.ForeignKeyAttribute && vf.ForeignType == sf.Type)) .AssertAll<ValueField>(vf => vf.ForeignType == nullType ^ vf.ForeignType.ValueFields.Any(vf2 => vf2.IsPrimaryKey && vf2.Type == vf.Type)) .Assert(() => categoryIdField.Owner == categoryType) .Assert(() => categoryIdField.Name == "CatId") .Assert(() => categoryIdField.Type == stringType) .Assert(() => categoryIdField.IsPrimaryKey == true) .Assert(() => categoryType.ValueFields == new[] { categoryIdField }) .Assert(() => productIdField.Owner == productType) .Assert(() => productIdField.Name == "ProdId") .Assert(() => productIdField.Type == guidType) .Assert(() => productIdField.IsPrimaryKey == true) .Assert(() => productCategoryIdField.Owner == productType) .Assert(() => productCategoryIdField.Name == "CategoryId") .Assert(() => productCategoryIdField.Type == stringType) .Assert(() => productCategoryField.Owner == productType) .Assert(() => productCategoryField.Name == "Category") .Assert(() => productCategoryField.Type == categoryType) .Assert(() => productType.ValueFields == new[] { productIdField, productCategoryIdField }) .Assert(() => productType.SingleFields == new[] { productCategoryField }); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => productCategoryField.ForeignKeyAttribute == "CategoryId"); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); var test = solved.GetValue(productCategoryIdField, p => p.Type); Assert.AreEqual(stringType, test); }
public void EFMetaModel_WithRefPropsAndAssert_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance <Category>("TypeInstance1"); var typeInstance2 = objectTheorem.CreateInstance <Category>("TypeInstance2"); var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1"); // Act objectTheorem.ConstraintBuilder .Assert(() => typeInstance1.IsHighlighted == false) .Assert(() => fieldInstance1.Category == typeInstance2) .Assert(() => fieldInstance1.Category.IsHighlighted == true); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); bool IsEntity1 = solved.GetValue(typeInstance1, i => i.IsHighlighted); bool IsEntity2 = solved.GetValue(typeInstance2, i => i.IsHighlighted); Assert.IsFalse(IsEntity1); Assert.IsTrue(IsEntity2); }
public void HM_WithRefPropsAndAssert_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType<Vehicle>(); var bicycleInstance1 = objectTheorem.CreateInstance<Bicycle>("BicycleInstance1"); var bicycleInstance2 = objectTheorem.CreateInstance<Bicycle>("BicycleInstance2"); var carInstance1 = objectTheorem.CreateInstance<Car>("CarInstance1"); // Act objectTheorem.ConstraintBuilder .AssertAll<Vehicle>(v => v.Speed > 0) .AssertAll<Bicycle, Car>((b, c) => b.Speed < c.Speed) .Assert(() => bicycleInstance1.Speed == 10); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); int bicycle1Speed = solved.GetValue(bicycleInstance1, i => i.Speed); int bicycle2Speed = solved.GetValue(bicycleInstance2, i => i.Speed); int carSpeed = solved.GetValue(carInstance1, i => i.Speed); Assert.AreEqual(10, bicycle1Speed); Assert.IsTrue(bicycle2Speed > 0); Assert.IsTrue(carSpeed > 0); Assert.IsTrue(bicycle1Speed < carSpeed); Assert.IsTrue(bicycle2Speed < carSpeed); }
public void EFMetaModel_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance <Category>("TypeInstance1"); var typeInstance2 = objectTheorem.CreateInstance <Category>("TypeInstance2"); var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1"); var fieldInstance2 = objectTheorem.CreateInstance <Product>("FieldInstance2"); // Act objectTheorem.ConstraintBuilder .AssertAll <Product>((f) => !f.Category.IsHighlighted || f.IsPremiumOnly == true) .Assert(() => typeInstance1.IsHighlighted == true) .Assert(() => fieldInstance1.Category == typeInstance1) .Assert(() => fieldInstance2.Category == typeInstance2) .Assert(() => !fieldInstance2.IsPremiumOnly); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); bool oneHasKeyAttribute = solved.GetValue(fieldInstance1, i => i.IsPremiumOnly); bool twoHasKeyAttribute = solved.GetValue(fieldInstance2, i => i.IsPremiumOnly); Assert.IsTrue(oneHasKeyAttribute); Assert.IsFalse(twoHasKeyAttribute); }
public void SM_WithStringPropsAndSamePossibleStrings_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var stringNames = new[] { "Hans", "Fred", "Max" }; objectTheorem.SetPossibleStringValues(stringNames); var classWithStringA = objectTheorem.CreateInstance<ClassWithStringA>("ClassWithStringA"); var classWithStringB = objectTheorem.CreateInstance<ClassWithStringB>("ClassWithStringB"); // Act objectTheorem.ConstraintBuilder .AssertAll<ClassWithStringA, ClassWithStringB>((a, b) => a.FirstName == b.LastName) .Assert(() => "Hans" == classWithStringA.FirstName); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); string firstName = solved.GetValue(classWithStringA, i => i.FirstName); string lastName = solved.GetValue(classWithStringB, i => i.LastName); Assert.AreEqual("Hans", firstName); Assert.AreEqual("Hans", lastName); }
public void IndexRule_Successful_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType <Type>(); objectTheorem.RegisterSuperType <Field>(); var valueField1 = objectTheorem.CreateInstance <ValueField>("ValueField1"); var stringType = objectTheorem.CreateInstance <ValueType>("StringType"); // Act EFConstraints.AddIndexRuleConstraints(objectTheorem.ConstraintBuilder, stringType); objectTheorem.ConstraintBuilder .Assert(() => valueField1.Type == stringType); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasIndexAttribute == true); var assume2 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasMaxLengthAttribute == true); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); }
public void EFMetaModel_WithAny_TwoItemArray_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1"); var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1"); var fieldInstance2 = objectTheorem.CreateInstance<Product>("FieldInstance2"); // Act objectTheorem.ConstraintBuilder .AssertAll<Category>(t => t.Products.Any(f1 => f1.IsPremiumOnly == true)) .Assert(() => typeInstance1.Products == new[] { fieldInstance1, fieldInstance2 }) .Assert(() => fieldInstance1.Category == typeInstance1) .Assert(() => fieldInstance2.Category == typeInstance1) .Assert(() => fieldInstance1.IsPremiumOnly == true) .Assert(() => fieldInstance2.IsPremiumOnly == true); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); bool oneHasKeyAttribute = solved.GetValue(fieldInstance1, i => i.IsPremiumOnly); bool twoHasKeyAttribute = solved.GetValue(fieldInstance2, i => i.IsPremiumOnly); Assert.IsTrue(oneHasKeyAttribute); Assert.IsTrue(twoHasKeyAttribute); }
public void EFMetaModel_WithAll_TwoItemArray_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance <Category>("TypeInstance1"); var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1"); var fieldInstance2 = objectTheorem.CreateInstance <Product>("FieldInstance2"); // Act objectTheorem.ConstraintBuilder .AssertAll <Category>(t => t.Products.All(f => f.IsPremiumOnly == true)) .Assert(() => typeInstance1.Products == new[] { fieldInstance1, fieldInstance2 }) .Assert(() => fieldInstance1.Category == typeInstance1) .Assert(() => fieldInstance2.Category == typeInstance1) .Assert(() => fieldInstance1.IsPremiumOnly == true) .Assert(() => fieldInstance2.IsPremiumOnly == true); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); bool oneHasKeyAttribute = solved.GetValue(fieldInstance1, i => i.IsPremiumOnly); bool twoHasKeyAttribute = solved.GetValue(fieldInstance2, i => i.IsPremiumOnly); Assert.IsTrue(oneHasKeyAttribute); Assert.IsTrue(twoHasKeyAttribute); }
public void HM_WithRefPropsAndAssert_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType <Vehicle>(); var bicycleInstance1 = objectTheorem.CreateInstance <Bicycle>("BicycleInstance1"); var bicycleInstance2 = objectTheorem.CreateInstance <Bicycle>("BicycleInstance2"); var carInstance1 = objectTheorem.CreateInstance <Car>("CarInstance1"); // Act objectTheorem.ConstraintBuilder .AssertAll <Vehicle>(v => v.Speed > 0) .AssertAll <Bicycle, Car>((b, c) => b.Speed < c.Speed) .Assert(() => bicycleInstance1.Speed == 10); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); int bicycle1Speed = solved.GetValue(bicycleInstance1, i => i.Speed); int bicycle2Speed = solved.GetValue(bicycleInstance2, i => i.Speed); int carSpeed = solved.GetValue(carInstance1, i => i.Speed); Assert.AreEqual(10, bicycle1Speed); Assert.IsTrue(bicycle2Speed > 0); Assert.IsTrue(carSpeed > 0); Assert.IsTrue(bicycle1Speed < carSpeed); Assert.IsTrue(bicycle2Speed < carSpeed); }
public void SM_WithStringPropsAndSamePossibleStrings_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var stringNames = new[] { "Hans", "Fred", "Max" }; objectTheorem.SetPossibleStringValues(stringNames); var classWithStringA = objectTheorem.CreateInstance <ClassWithStringA>("ClassWithStringA"); var classWithStringB = objectTheorem.CreateInstance <ClassWithStringB>("ClassWithStringB"); // Act objectTheorem.ConstraintBuilder .AssertAll <ClassWithStringA, ClassWithStringB>((a, b) => a.FirstName == b.LastName) .Assert(() => "Hans" == classWithStringA.FirstName); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); string firstName = solved.GetValue(classWithStringA, i => i.FirstName); string lastName = solved.GetValue(classWithStringB, i => i.LastName); Assert.AreEqual("Hans", firstName); Assert.AreEqual("Hans", lastName); }
public void DatabaseGeneratedRule_Successful_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType<Type>(); var employeeType = objectTheorem.CreateInstance<ReferenceType>("EmployeeType"); objectTheorem.RegisterSuperType<Field>(); objectTheorem.SetPossibleStringValues("Id", "ID", "EmployeeTypeId", "EmployeeTypeID"); var idField = objectTheorem.CreateInstance<ValueField>("IdField"); var stringType = objectTheorem.CreateInstance<ValueType>("StringType"); var numberType = objectTheorem.CreateInstance<ValueType>("NumberType"); var guidType = objectTheorem.CreateInstance<ValueType>("GuidType"); // Act EFConstraints.AddPrimayKeyRuleConstraints(objectTheorem.ConstraintBuilder); EFConstraints.AddDatabaseGeneratedRuleConstraints(objectTheorem.ConstraintBuilder, stringType, numberType, guidType); objectTheorem.ConstraintBuilder .Assert(() => employeeType.IsEntity == true) .Assert(() => employeeType.ValueFields == new[] { idField }) .Assert(() => idField.Name == "Id") .Assert(() => idField.Owner == employeeType) .Assert(() => idField.Type == numberType) .Assert(() => idField.DatabaseGeneratedAttribute == DatabaseGeneratedAttribute.None); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => idField.DatabaseGeneratedAttribute == DatabaseGeneratedAttribute.None); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); }
public void NotMappedRule_Unsuccessful_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType<Type>(); objectTheorem.RegisterSuperType<Field>(); objectTheorem.RegisterSuperType<ReferenceField>(); var customerType = objectTheorem.CreateInstance<ReferenceType>("Customer1"); var addressType = objectTheorem.CreateInstance<ReferenceType>("Address1"); var arrayOfAddressField = objectTheorem.CreateInstance<CollectionField>("AddressField"); var namesField = objectTheorem.CreateInstance<ValueField>("NamesField"); var arrayOfStringType = objectTheorem.CreateInstance<ValueType>("CollectionOfStringType"); // Act EFConstraints.AddNotMappedRuleConstraints(objectTheorem.ConstraintBuilder, new[] { arrayOfStringType }); objectTheorem.ConstraintBuilder .Assert(() => customerType.ValueFields == new[] { namesField }) .Assert(() => namesField.Owner == customerType) .Assert(() => namesField.Type == arrayOfStringType) .Assert(() => customerType.CollectionFields == new[] { arrayOfAddressField }) .Assert(() => arrayOfAddressField.Owner == customerType) .Assert(() => arrayOfAddressField.Type == addressType) .Assert(() => addressType.HasComplexTypeAttribute == true); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => arrayOfAddressField.HasNotMappedAttribute == false); var assume2 = objectTheorem.ConstraintBuilder.Assume(() => namesField.HasNotMappedAttribute == false); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Unsatisfiable, solved.Status); var assume1Result = solved.IsAssumptionWrong(assume1); Assert.IsTrue(assume1Result); objectTheorem.ConstraintBuilder.RemoveAssumption(assume1); solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Unsatisfiable, solved.Status); var assume2Result = solved.IsAssumptionWrong(assume2); Assert.IsTrue(assume2Result); objectTheorem.ConstraintBuilder.RemoveAssumption(assume2); solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); bool HasNotMappedAttribute1 = solved.GetValue(arrayOfAddressField, f => f.HasNotMappedAttribute); bool HasNotMappedAttribute2 = solved.GetValue(namesField, f => f.HasNotMappedAttribute); Assert.IsTrue(HasNotMappedAttribute1); Assert.IsTrue(HasNotMappedAttribute2); }
public void IdKeyDiscoveryConvention_Successful_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType <Z3.ObjectTheorem.EF.Metamodel.Type>(); var employeeType = objectTheorem.CreateInstance <ReferenceType>("EmployeeType"); objectTheorem.RegisterSuperType <Field>(); objectTheorem.SetPossibleStringValues("Id", "Name", "Income", "ID", "EmployeeTypeId", "EmployeeTypeID"); var idField = objectTheorem.CreateInstance <ValueField>("IdField"); var nameField = objectTheorem.CreateInstance <ValueField>("NameField"); var incomeField = objectTheorem.CreateInstance <ValueField>("IncomeField"); // Act EFConstraints.AddPrimayKeyRuleConstraints(objectTheorem.ConstraintBuilder); objectTheorem.ConstraintBuilder .Assert(() => employeeType.IsEntity == true) .Assert(() => employeeType.ValueFields == new[] { idField, nameField, incomeField }) .Assert(() => idField.Name == "Id") .Assert(() => idField.Owner == employeeType) .Assert(() => nameField.Name == "Name") .Assert(() => nameField.Owner == employeeType) .Assert(() => incomeField.Name == "Income") .Assert(() => incomeField.Owner == employeeType); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => idField.HasKeyAttribute == false); var assume2 = objectTheorem.ConstraintBuilder.Assume(() => nameField.HasKeyAttribute == false); var assume3 = objectTheorem.ConstraintBuilder.Assume(() => incomeField.HasKeyAttribute == false); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); bool HasKeyAttribute1 = solved.GetValue(idField, i => i.HasKeyAttribute); bool HasKeyAttribute2 = solved.GetValue(nameField, i => i.HasKeyAttribute); bool HasKeyAttribute3 = solved.GetValue(incomeField, i => i.HasKeyAttribute); Assert.IsFalse(HasKeyAttribute1); Assert.IsFalse(HasKeyAttribute2); Assert.IsFalse(HasKeyAttribute3); bool IsPrimaryKey1 = solved.GetValue(idField, i => i.IsPrimaryKey); bool IsPrimaryKey2 = solved.GetValue(nameField, i => i.IsPrimaryKey); bool IsPrimaryKey3 = solved.GetValue(incomeField, i => i.IsPrimaryKey); Assert.IsTrue(IsPrimaryKey1); Assert.IsFalse(IsPrimaryKey2); Assert.IsFalse(IsPrimaryKey3); }
public void IndexRule_Unsuccessful_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType <Type>(); objectTheorem.RegisterSuperType <Field>(); var valueField1 = objectTheorem.CreateInstance <ValueField>("ValueField1"); var stringType = objectTheorem.CreateInstance <ValueType>("StringType"); // Act EFConstraints.AddIndexRuleConstraints(objectTheorem.ConstraintBuilder, stringType); objectTheorem.ConstraintBuilder .Assert(() => valueField1.Type == stringType); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasIndexAttribute == true); var assume2 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasMaxLengthAttribute == false); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Unsatisfiable, solved.Status); var assume1Result = solved.IsAssumptionWrong(assume1); Assert.IsTrue(assume1Result); objectTheorem.ConstraintBuilder.RemoveAssumption(assume1); solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); bool HasComplexTypeAttribute = solved.GetValue(valueField1, i => i.HasIndexAttribute); Assert.IsFalse(HasComplexTypeAttribute); }
public void IndexRule_Unsuccessful_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType<Type>(); objectTheorem.RegisterSuperType<Field>(); var valueField1 = objectTheorem.CreateInstance<ValueField>("ValueField1"); var stringType = objectTheorem.CreateInstance<ValueType>("StringType"); // Act EFConstraints.AddIndexRuleConstraints(objectTheorem.ConstraintBuilder, stringType); objectTheorem.ConstraintBuilder .Assert(() => valueField1.Type == stringType); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasIndexAttribute == true); var assume2 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasMaxLengthAttribute == false); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Unsatisfiable, solved.Status); var assume1Result = solved.IsAssumptionWrong(assume1); Assert.IsTrue(assume1Result); objectTheorem.ConstraintBuilder.RemoveAssumption(assume1); solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); bool HasComplexTypeAttribute = solved.GetValue(valueField1, i => i.HasIndexAttribute); Assert.IsFalse(HasComplexTypeAttribute); }
public void SM_WithStringProps_ShouldBe_Unsatisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.SetPossibleStringValues("Hans", "Fred"); var classWithStringA = objectTheorem.CreateInstance<ClassWithStringA>("ClassWithStringA"); // Act objectTheorem.ConstraintBuilder .AssertAll<ClassWithStringA>(c => c.FirstName != "Hans") .Assert(() => "Fred" != classWithStringA.FirstName); // Assert var solved = objectTheorem.Solve(); Assert.IsNull(solved); }
public void EFMetaModel_WithRefPropsAndAssertAll_ShouldBe_Unsatisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1"); var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1"); // Act objectTheorem.ConstraintBuilder .AssertAll<Product>((f) => f.Category.IsHighlighted == true) .Assert(() => fieldInstance1.Category == typeInstance1) .Assert(() => typeInstance1.IsHighlighted == false); // Assert var solved = objectTheorem.Solve(); Assert.IsNull(solved); }
public void EFMetaModel_WithRefPropsAndAssertAll_ShouldBe_Unsatisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance <Category>("TypeInstance1"); var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1"); // Act objectTheorem.ConstraintBuilder .AssertAll <Product>((f) => f.Category.IsHighlighted == true) .Assert(() => fieldInstance1.Category == typeInstance1) .Assert(() => typeInstance1.IsHighlighted == false); // Assert var solved = objectTheorem.Solve(); Assert.IsNull(solved); }
public void SimpleModel_ShouldBe_NotSatisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var classAInstance = objectTheorem.CreateInstance <ClassA>("ClassAInstance"); var classBInstance = objectTheorem.CreateInstance <ClassB>("ClassBInstance"); // Act objectTheorem.ConstraintBuilder .AssertAll <ClassA, ClassB>((a, b) => a.IsValidA == b.IsValidB) .Assert(() => classAInstance.IsValidA == true) .Assert(() => classBInstance.IsValidB == false); // Assert var solved = objectTheorem.Solve(); Assert.IsNull(solved); }
public void SM_WithStringProps_ShouldBe_Unsatisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.SetPossibleStringValues("Hans", "Fred"); var classWithStringA = objectTheorem.CreateInstance <ClassWithStringA>("ClassWithStringA"); // Act objectTheorem.ConstraintBuilder .AssertAll <ClassWithStringA>(c => c.FirstName != "Hans") .Assert(() => "Fred" != classWithStringA.FirstName); // Assert var solved = objectTheorem.Solve(); Assert.IsNull(solved); }
public void EFMetaModel_WithRefPropsAndAssertAll_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1"); var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1"); // Act objectTheorem.ConstraintBuilder .AssertAll<Product>((f) => f.Category.IsHighlighted == true) .Assert(() => fieldInstance1.Category == typeInstance1); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); bool IsEntity1 = solved.GetValue(typeInstance1, i => i.IsHighlighted); Assert.IsTrue(IsEntity1); }
public void EFMetaModel_WithRequiredAny_EmptyArray_ShouldBe_Unsatisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance <Category>("TypeInstance1"); var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1"); var fieldInstance2 = objectTheorem.CreateInstance <Product>("FieldInstance2"); // Act objectTheorem.ConstraintBuilder .AssertAll <Category>(t => t.Products.Any(f1 => f1.IsPremiumOnly == true)) .Assert(() => typeInstance1.Products == new Product[0]); // Assert var solved = objectTheorem.Solve(); Assert.IsNull(solved); }
public void EFMetaModel_WithRequiredEmptyArray_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1"); var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1"); // Act objectTheorem.ConstraintBuilder .Assert(() => typeInstance1.Products == new Product[0]); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); System.Collections.Generic.IEnumerable<Product> products1 = solved.GetValue(typeInstance1, i => i.Products); Assert.AreEqual(0, products1.Count()); }
public void EFMetaModel_WithAllOneRequiredItemInList_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance <Category>("TypeInstance1"); var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1"); // Act objectTheorem.ConstraintBuilder .AssertAll <Category>(t => t.Products == new [] { fieldInstance1 }); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); System.Collections.Generic.IEnumerable <Product> products1 = solved.GetValue(typeInstance1, i => i.Products); CollectionAssert.AreEquivalent(new[] { fieldInstance1 }, products1.ToList()); }
public void EFMetaModel_WithRequiredEmptyArray_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance <Category>("TypeInstance1"); var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1"); // Act objectTheorem.ConstraintBuilder .Assert(() => typeInstance1.Products == new Product[0]); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); System.Collections.Generic.IEnumerable <Product> products1 = solved.GetValue(typeInstance1, i => i.Products); Assert.AreEqual(0, products1.Count()); }
public void EnumValues_ShouldBe_Satisfiable2() { // Arrange var objectTheorem = new ObjectTheoremContext(); var classAInstance1 = objectTheorem.CreateInstance<ClassA>("ClassAInstance"); var classAInstance2 = objectTheorem.CreateInstance<ClassA>("ClassBInstance"); // Act objectTheorem.ConstraintBuilder .Assert(() => classAInstance1.Color != classAInstance2.Color) .Assert(() => classAInstance1.Color == Colors.Black); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Colors color1 = solved.GetValue(classAInstance1, i => i.Color); Colors color2 = solved.GetValue(classAInstance2, i => i.Color); Assert.IsTrue(color1 != color2); Assert.AreEqual(Colors.Black, color1); }
public void NotMappedRule_Successful_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType <Type>(); objectTheorem.RegisterSuperType <Field>(); objectTheorem.RegisterSuperType <ReferenceField>(); var customerType = objectTheorem.CreateInstance <ReferenceType>("Customer1"); var addressType = objectTheorem.CreateInstance <ReferenceType>("Address1"); var arrayOfAddressField = objectTheorem.CreateInstance <CollectionField>("AddressField"); var namesField = objectTheorem.CreateInstance <ValueField>("NamesField"); var arrayOfStringType = objectTheorem.CreateInstance <ValueType>("CollectionOfStringType"); // Act EFConstraints.AddNotMappedRuleConstraints(objectTheorem.ConstraintBuilder, new[] { arrayOfStringType }); objectTheorem.ConstraintBuilder .Assert(() => customerType.ValueFields == new[] { namesField }) .Assert(() => namesField.Owner == customerType) .Assert(() => namesField.Type == arrayOfStringType) .Assert(() => customerType.CollectionFields == new[] { arrayOfAddressField }) .Assert(() => arrayOfAddressField.Owner == customerType) .Assert(() => arrayOfAddressField.Type == addressType) .Assert(() => addressType.HasComplexTypeAttribute == true); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => arrayOfAddressField.HasNotMappedAttribute == true); var assume2 = objectTheorem.ConstraintBuilder.Assume(() => namesField.HasNotMappedAttribute == true); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); }
public void DatabaseGeneratedRule_Successful_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType <Type>(); var employeeType = objectTheorem.CreateInstance <ReferenceType>("EmployeeType"); objectTheorem.RegisterSuperType <Field>(); objectTheorem.SetPossibleStringValues("Id", "ID", "EmployeeTypeId", "EmployeeTypeID"); var idField = objectTheorem.CreateInstance <ValueField>("IdField"); var stringType = objectTheorem.CreateInstance <ValueType>("StringType"); var numberType = objectTheorem.CreateInstance <ValueType>("NumberType"); var guidType = objectTheorem.CreateInstance <ValueType>("GuidType"); // Act EFConstraints.AddPrimayKeyRuleConstraints(objectTheorem.ConstraintBuilder); EFConstraints.AddDatabaseGeneratedRuleConstraints(objectTheorem.ConstraintBuilder, stringType, numberType, guidType); objectTheorem.ConstraintBuilder .Assert(() => employeeType.IsEntity == true) .Assert(() => employeeType.ValueFields == new[] { idField }) .Assert(() => idField.Name == "Id") .Assert(() => idField.Owner == employeeType) .Assert(() => idField.Type == numberType) .Assert(() => idField.DatabaseGeneratedAttribute == DatabaseGeneratedAttribute.None); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => idField.DatabaseGeneratedAttribute == DatabaseGeneratedAttribute.None); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); }
public ObjectTheoremResult ReSolve() { return(_objectTheorem.Solve()); }
public void EFMetaModel_WithAllOneRequiredItemInList_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1"); var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1"); // Act objectTheorem.ConstraintBuilder .AssertAll<Category>(t => t.Products == new []{ fieldInstance1 }); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); System.Collections.Generic.IEnumerable<Product> products1 = solved.GetValue(typeInstance1, i => i.Products); CollectionAssert.AreEquivalent(new[] { fieldInstance1 }, products1.ToList()); }
public void EFMetaModel_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1"); var typeInstance2 = objectTheorem.CreateInstance<Category>("TypeInstance2"); var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1"); var fieldInstance2 = objectTheorem.CreateInstance<Product>("FieldInstance2"); // Act objectTheorem.ConstraintBuilder .AssertAll<Product>((f) => !f.Category.IsHighlighted || f.IsPremiumOnly == true) .Assert(() => typeInstance1.IsHighlighted == true) .Assert(() => fieldInstance1.Category == typeInstance1) .Assert(() => fieldInstance2.Category == typeInstance2) .Assert(() => !fieldInstance2.IsPremiumOnly); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); bool oneHasKeyAttribute = solved.GetValue(fieldInstance1, i => i.IsPremiumOnly); bool twoHasKeyAttribute = solved.GetValue(fieldInstance2, i => i.IsPremiumOnly); Assert.IsTrue(oneHasKeyAttribute); Assert.IsFalse(twoHasKeyAttribute); }
public void ForeignKeyDiscoveryConvention_Successful_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); objectTheorem.RegisterSuperType <Type>(); objectTheorem.RegisterSuperType <Field>(); objectTheorem.RegisterSuperType <ReferenceField>(); var nullType = objectTheorem.CreateInstance <ReferenceType>("NullType"); var categoryType = objectTheorem.CreateInstance <ReferenceType>("CategoryType"); var categoryIdField = objectTheorem.CreateInstance <ValueField>("CategoryIdField"); var productType = objectTheorem.CreateInstance <ReferenceType>("ProductType"); var productIdField = objectTheorem.CreateInstance <ValueField>("ProductIdField"); var productCategoryIdField = objectTheorem.CreateInstance <ValueField>("productCategoryIdField"); var productCategoryField = objectTheorem.CreateInstance <SingleField>("productCategoryField"); var stringType = objectTheorem.CreateInstance <ValueType>("StringType"); var numberType = objectTheorem.CreateInstance <ValueType>("NumberType"); var guidType = objectTheorem.CreateInstance <ValueType>("GuidType"); objectTheorem.SetPossibleStringValues("CatId", "ProdId", "CategoryId", "Category", "-"); // Act objectTheorem.ConstraintBuilder .AssertAll <SingleField>(sf => sf.Owner.ValueFields.Any(vf => vf.Name == sf.ForeignKeyAttribute && vf.ForeignType == sf.Type)) .AssertAll <ValueField>(vf => vf.ForeignType == nullType ^ vf.ForeignType.ValueFields.Any(vf2 => vf2.IsPrimaryKey && vf2.Type == vf.Type)) .Assert(() => categoryIdField.Owner == categoryType) .Assert(() => categoryIdField.Name == "CatId") .Assert(() => categoryIdField.Type == stringType) .Assert(() => categoryIdField.IsPrimaryKey == true) .Assert(() => categoryType.ValueFields == new[] { categoryIdField }) .Assert(() => productIdField.Owner == productType) .Assert(() => productIdField.Name == "ProdId") .Assert(() => productIdField.Type == guidType) .Assert(() => productIdField.IsPrimaryKey == true) .Assert(() => productCategoryIdField.Owner == productType) .Assert(() => productCategoryIdField.Name == "CategoryId") .Assert(() => productCategoryIdField.Type == stringType) .Assert(() => productCategoryField.Owner == productType) .Assert(() => productCategoryField.Name == "Category") .Assert(() => productCategoryField.Type == categoryType) .Assert(() => productType.ValueFields == new[] { productIdField, productCategoryIdField }) .Assert(() => productType.SingleFields == new[] { productCategoryField }); var assume1 = objectTheorem.ConstraintBuilder.Assume(() => productCategoryField.ForeignKeyAttribute == "CategoryId"); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); Assert.AreEqual(Status.Satisfiable, solved.Status); var test = solved.GetValue(productCategoryIdField, p => p.Type); Assert.AreEqual(stringType, test); }
public void SimpleModel_ShouldBe_NotSatisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var classAInstance = objectTheorem.CreateInstance<ClassA>("ClassAInstance"); var classBInstance = objectTheorem.CreateInstance<ClassB>("ClassBInstance"); // Act objectTheorem.ConstraintBuilder .AssertAll<ClassA, ClassB>((a, b) => a.IsValidA == b.IsValidB) .Assert(() => classAInstance.IsValidA == true) .Assert(() => classBInstance.IsValidB == false); // Assert var solved = objectTheorem.Solve(); Assert.IsNull(solved); }
public void EFMetaModel_WithAny_TwoItemArray_ShouldBe_Unsatisfiable2() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1"); var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1"); var fieldInstance2 = objectTheorem.CreateInstance<Product>("FieldInstance2"); // Act objectTheorem.ConstraintBuilder .AssertAll<Category>(t => t.Products.Any(f1 => f1.IsPremiumOnly == true)) .Assert(() => typeInstance1.Products == new[] { fieldInstance1 }) .Assert(() => fieldInstance1.Category == typeInstance1) .Assert(() => fieldInstance1.IsPremiumOnly == false) .Assert(() => fieldInstance2.IsPremiumOnly == true); // Assert var solved = objectTheorem.Solve(); Assert.IsNull(solved); }
// TODO: results in UNKNOWN //[TestMethod] public void EFMetaModel_WithOptionalAny_EmptyArray_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1"); var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1"); var fieldInstance2 = objectTheorem.CreateInstance<Product>("FieldInstance2"); // Act objectTheorem.ConstraintBuilder .AssertAll<Category>(t => t.Products == new Product[0] || t.Products.Any(f1 => f1.IsPremiumOnly == true)) .Assert(() => typeInstance1.Products == new Product[0]); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); }
public void SimpleModel_OutsideConstant_ShouldBe_Satisfiable() { // Arrange var objectTheorem = new ObjectTheoremContext(); var outsideBoolConstant = true; var classAInstance = objectTheorem.CreateInstance<ClassA>("ClassAInstance"); var classBInstance = objectTheorem.CreateInstance<ClassB>("ClassBInstance"); // Act objectTheorem.ConstraintBuilder .AssertAll<ClassA, ClassB>((a, b) => a.IsValidA == b.IsValidB) .Assert(() => classAInstance.IsValidA == outsideBoolConstant); // Assert var solved = objectTheorem.Solve(); Assert.IsNotNull(solved); bool isValidA = solved.GetValue(classAInstance, i => i.IsValidA); bool isValidB = solved.GetValue(classBInstance, i => i.IsValidB); Assert.IsTrue(isValidA); Assert.IsTrue(isValidB); }