public void ReturnOwnSignsOnlyIfNoRecursion()
{
// arrange
var language = Language.Default;
var semanticNetwork = new TestSemanticNetwork(language);
var ownSign = ConceptCreationHelper.CreateConcept();
ownSign.WithAttribute(IsSignAttribute.Value);
semanticNetwork.SemanticNetwork.Concepts.Add(ownSign);
var ownSignStatement = semanticNetwork.SemanticNetwork.DeclareThat(semanticNetwork.Vehicle_Motorcycle).HasSign(ownSign);
var questionOwnSign = new HasSignsQuestion(semanticNetwork.Base_Vehicle, false);
var questionInheritedSign = new HasSignsQuestion(semanticNetwork.Vehicle_Motorcycle, false);
// act
var answerOwnSign = questionOwnSign.Ask(semanticNetwork.SemanticNetwork.Context);
var answerInheritedSign = questionInheritedSign.Ask(semanticNetwork.SemanticNetwork.Context);
// assert
Assert.IsFalse(answerOwnSign.IsEmpty);
Assert.IsTrue(((BooleanAnswer)answerOwnSign).Result);
Assert.AreEqual(2, answerOwnSign.Explanation.Statements.Count);
Assert.IsFalse(answerInheritedSign.IsEmpty);
Assert.IsTrue(((BooleanAnswer)answerInheritedSign).Result);
Assert.AreSame(ownSignStatement, answerInheritedSign.Explanation.Statements.Single());
}
public void WhenNoRelationshipsReturnEmptyAnswer()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var conceptToCheck = ConceptCreationHelper.CreateConcept();
var parentConcept = ConceptCreationHelper.CreateConcept();
var childConcept = ConceptCreationHelper.CreateConcept();
semanticNetwork.Concepts.Add(conceptToCheck);
semanticNetwork.Concepts.Add(parentConcept);
semanticNetwork.Concepts.Add(childConcept);
semanticNetwork.DeclareThat(childConcept).IsDescendantOf(parentConcept);
// act
var answerToCheck = semanticNetwork.Ask().WhichAncestorsHas(conceptToCheck);
var answerChild = semanticNetwork.Ask().WhichAncestorsHas(parentConcept);
// assert
Assert.IsTrue(answerToCheck.IsEmpty);
Assert.AreEqual(0, answerToCheck.Explanation.Statements.Count);
Assert.IsTrue(answerChild.IsEmpty);
Assert.AreEqual(0, answerChild.Explanation.Statements.Count);
}
public void ReturnAllSignsIfRecursive()
{
// arrange
var language = Language.Default;
var semanticNetwork = new TestSemanticNetwork(language);
var ownSign = ConceptCreationHelper.CreateConcept();
ownSign.WithAttribute(IsSignAttribute.Value);
semanticNetwork.SemanticNetwork.Concepts.Add(ownSign);
var ownSignStatement = semanticNetwork.SemanticNetwork.DeclareThat(semanticNetwork.Vehicle_Motorcycle).HasSign(ownSign);
// act
var answerOwnSign = semanticNetwork.SemanticNetwork.Ask().IfHasSign(semanticNetwork.Vehicle_Motorcycle, ownSign);
var answerInheritedSign = semanticNetwork.SemanticNetwork.Ask().IfHasSign(semanticNetwork.Vehicle_Motorcycle, semanticNetwork.Sign_AreaType);
// assert
Assert.IsFalse(answerOwnSign.IsEmpty);
Assert.IsTrue(((BooleanAnswer)answerOwnSign).Result);
Assert.AreSame(ownSignStatement, answerOwnSign.Explanation.Statements.Single());
Assert.IsFalse(answerInheritedSign.IsEmpty);
Assert.IsTrue(((BooleanAnswer)answerInheritedSign).Result);
Assert.AreEqual(2, answerInheritedSign.Explanation.Statements.Count);
Assert.AreEqual(1, answerInheritedSign.Explanation.Statements.OfType <HasSignStatement>().Count());
Assert.AreEqual(1, answerInheritedSign.Explanation.Statements.OfType <IsStatement>().Count());
}
public void TestBuildingWhatIsMutualSequenceOfProcesses()
{
// arrange
var language = Language.Default;
var semanticNetwork = new TestSemanticNetwork(language);
var processA = ConceptCreationHelper.CreateConcept();
processA.WithAttribute(IsProcessAttribute.Value);
var processB = ConceptCreationHelper.CreateConcept();
processB.WithAttribute(IsProcessAttribute.Value);
semanticNetwork.SemanticNetwork.DeclareThat(processA).StartsBeforeOtherStarted(processB);
semanticNetwork.SemanticNetwork.DeclareThat(processA).FinishesAfterOtherFinished(processB);
// act
var questionRegular = new ProcessesQuestion(processA, processB);
var answerRegular = (StatementsAnswer <ProcessesStatement>)questionRegular.Ask(semanticNetwork.SemanticNetwork.Context);
var answerBuilder = (StatementsAnswer <ProcessesStatement>)semanticNetwork.SemanticNetwork.Ask().WhatIsMutualSequenceOfProcesses(processA, processB);
// assert
Assert.IsTrue(answerRegular.Result.SequenceEqual(answerBuilder.Result));
Assert.IsTrue(answerRegular.Explanation.Statements.SequenceEqual(answerBuilder.Explanation.Statements));
}
public void ReturnAllParents()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var childConcept = ConceptCreationHelper.CreateConcept();
semanticNetwork.Concepts.Add(childConcept);
const int parentCount = 4;
for (int i = 1; i <= parentCount; i++)
{
// act
var parentConcept = ConceptCreationHelper.CreateConcept();
semanticNetwork.Concepts.Add(parentConcept);
semanticNetwork.DeclareThat(parentConcept).IsAncestorOf(childConcept);
var answer = semanticNetwork.Ask().WhichAncestorsHas(childConcept);
// assert
Assert.IsFalse(answer.IsEmpty);
var parentConcepts = ((ConceptsAnswer)answer).Result;
Assert.AreEqual(i, parentConcepts.Count);
Assert.IsTrue(parentConcepts.All(semanticNetwork.Concepts.Contains));
Assert.AreEqual(i, answer.Explanation.Statements.Count);
Assert.IsFalse(semanticNetwork.Statements.Except(answer.Explanation.Statements).Any());
}
}
public void WhenNoRelationshipsReturnEmptyAnswer()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var conceptToCheck = ConceptCreationHelper.CreateConcept();
var wholeConcept = ConceptCreationHelper.CreateConcept();
var partConcept = ConceptCreationHelper.CreateConcept();
semanticNetwork.Concepts.Add(conceptToCheck);
semanticNetwork.Concepts.Add(wholeConcept);
semanticNetwork.Concepts.Add(partConcept);
semanticNetwork.DeclareThat(partConcept).IsPartOf(wholeConcept);
// act
var answerToCheck = semanticNetwork.Ask().WhichContainersInclude(conceptToCheck);
var answerWhole = semanticNetwork.Ask().WhichContainersInclude(wholeConcept);
// assert
Assert.IsTrue(answerToCheck.IsEmpty);
Assert.AreEqual(0, answerToCheck.Explanation.Statements.Count);
Assert.IsTrue(answerWhole.IsEmpty);
Assert.AreEqual(0, answerWhole.Explanation.Statements.Count);
}
public void GivenNoAreaWhenTryToCreateGroupStatementThenFail()
{
// arrange
var concept = ConceptCreationHelper.CreateConcept();
// act && assert
Assert.Throws <ArgumentNullException>(() => new GroupStatement(TestStatementId, null, concept));
}
public void GivenNoSignWhenTryToCreateHasSignStatementThenFail()
{
// arrange
var concept = ConceptCreationHelper.CreateConcept();
// act && assert
Assert.Throws <ArgumentNullException>(() => new HasSignStatement(TestStatementId, concept, null));
}
public void GivenSignWithoutAttributeWhenTryToCreateHasSignStatementThenFail()
{
// arrange
var concept = ConceptCreationHelper.CreateConcept();
var sign = ConceptCreationHelper.CreateConcept();
// act && assert
Assert.Throws <ArgumentException>(() => new HasSignStatement(TestStatementId, concept, sign));
}
public void GivenNoConceptWhenTryToCreateHasSignStatementThenFail()
{
// arrange
var sign = ConceptCreationHelper.CreateConcept();
sign.WithAttribute(IsSignAttribute.Value);
// act && assert
Assert.Throws <ArgumentNullException>(() => new HasSignStatement(TestStatementId, null, sign));
}
public void GivenValueWithoutAttributeWhenTryToCreateSignValueStatementThenFail()
{
// arrange
var concept = ConceptCreationHelper.CreateConcept();
var sign = ConceptCreationHelper.CreateConcept();
sign.WithAttribute(IsSignAttribute.Value);
var value = ConceptCreationHelper.CreateConcept();
// act && assert
Assert.Throws <ArgumentException>(() => new SignValueStatement(TestStatementId, concept, sign, value));
}
public void GivenNoSignWhenTryToCreateProcessesStatementThenFail()
{
// arrange
var processA = ConceptCreationHelper.CreateConcept();
processA.WithAttribute(IsProcessAttribute.Value);
var processB = ConceptCreationHelper.CreateConcept();
processB.WithAttribute(IsProcessAttribute.Value);
// act && assert
Assert.Throws <ArgumentNullException>(() => new ProcessesStatement(TestStatementId, processA, processB, null));
}
public void GivenNoSignWhenTryToCreateComparisonStatementThenFail()
{
// arrange
var left = ConceptCreationHelper.CreateConcept();
left.WithAttribute(IsValueAttribute.Value);
var right = ConceptCreationHelper.CreateConcept();
right.WithAttribute(IsValueAttribute.Value);
// act && assert
Assert.Throws <ArgumentNullException>(() => new ComparisonStatement(TestStatementId, left, right, null));
}
public void GivenRightWithoutAttributeWhenTryToCreateComparisonStatementThenFail()
{
// arrange
var left = ConceptCreationHelper.CreateConcept();
left.WithAttribute(IsValueAttribute.Value);
var right = ConceptCreationHelper.CreateConcept();
var sign = ConceptCreationHelper.CreateConcept();
sign.WithAttribute(IsComparisonSignAttribute.Value);
// act && assert
Assert.Throws <ArgumentException>(() => new ComparisonStatement(TestStatementId, left, right, sign));
}
public void CheckPathFinding()
{
var parent1 = ConceptCreationHelper.CreateConcept();
var topMedium1 = ConceptCreationHelper.CreateConcept();
var bottomMedium1 = ConceptCreationHelper.CreateConcept();
var child1 = ConceptCreationHelper.CreateConcept();
var parent2 = ConceptCreationHelper.CreateConcept();
var topMedium2 = ConceptCreationHelper.CreateConcept();
var bottomMedium2 = ConceptCreationHelper.CreateConcept();
var child2 = ConceptCreationHelper.CreateConcept();
var parentNoConnection = ConceptCreationHelper.CreateConcept();
var childNoConnection = ConceptCreationHelper.CreateConcept();
var parent2Path = ConceptCreationHelper.CreateConcept();
var medium2Path1 = ConceptCreationHelper.CreateConcept();
var medium2Path2 = ConceptCreationHelper.CreateConcept();
var child2Path = ConceptCreationHelper.CreateConcept();
var statements = new IStatement[]
{
new TestPath(parent1, topMedium1),
new TestPath(topMedium1, bottomMedium1),
new TestPath(bottomMedium1, child1),
new TestPath(parent2, topMedium2),
new TestPath(topMedium2, bottomMedium2),
new TestPath(bottomMedium2, child2),
new IsStatement(null, parentNoConnection, childNoConnection),
new TestPath(parent2Path, medium2Path1),
new TestPath(parent2Path, medium2Path2),
new TestPath(medium2Path1, child2Path),
new TestPath(medium2Path2, child2Path),
};
// valid direct paths
Assert.IsTrue(statements.FindPath <IConcept>(typeof(TestPath), parent1, child1).Any());
Assert.IsTrue(statements.FindPath <IConcept>(typeof(TestPath), parent2, child2).Any());
// invalid direct paths
Assert.IsFalse(statements.FindPath <IConcept>(typeof(TestPath), parent1, child2).Any());
Assert.IsFalse(statements.FindPath <IConcept>(typeof(TestPath), parent2, child1).Any());
// invalid reverted paths
Assert.IsFalse(statements.FindPath <IConcept>(typeof(TestPath), child1, parent1).Any());
Assert.IsFalse(statements.FindPath <IConcept>(typeof(TestPath), child2, parent2).Any());
Assert.IsFalse(statements.FindPath <IConcept>(typeof(TestPath), child1, parent2).Any());
Assert.IsFalse(statements.FindPath <IConcept>(typeof(TestPath), child2, parent1).Any());
// other type path
Assert.IsFalse(statements.FindPath <IConcept>(typeof(TestPath), parentNoConnection, childNoConnection).Any());
Assert.IsTrue(statements.FindPath <IConcept>(typeof(IsStatement), parentNoConnection, childNoConnection).Any());
// 2 paths
Assert.IsTrue(statements.FindPath <IConcept>(typeof(TestPath), parent2Path, child2Path).Any());
Assert.IsFalse(statements.FindPath <IConcept>(typeof(TestPath), child2Path, parent2Path).Any());
}
public void GivenProcessBWithoutAttributeWhenTryToCreateProcessesStatementThenFail()
{
// arrange
var processA = ConceptCreationHelper.CreateConcept();
processA.WithAttribute(IsProcessAttribute.Value);
var processB = ConceptCreationHelper.CreateConcept();
var sign = ConceptCreationHelper.CreateConcept();
sign.WithAttribute(IsSequenceSignAttribute.Value);
// act && assert
Assert.Throws <ArgumentException>(() => new ProcessesStatement(TestStatementId, processA, processB, sign));
}
public void ReturnFalseIfNoAttribute()
{
// arrange
var language = Language.Default;
var semanticNetwork = new TestSemanticNetwork(language).SemanticNetwork;
var concept = ConceptCreationHelper.CreateConcept();
semanticNetwork.Concepts.Add(concept);
// act
var answer = semanticNetwork.Ask().IfIsSign(concept);
// assert
Assert.IsFalse(answer.IsEmpty);
Assert.IsFalse(((BooleanAnswer)answer).Result);
Assert.AreEqual(0, answer.Explanation.Statements.Count);
}
public void TestBuildingIsStatement()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var ancestor = ConceptCreationHelper.CreateConcept();
var descendant = ConceptCreationHelper.CreateConcept();
// act
var statementByConstuctor = new IsStatement(null, ancestor, descendant);
var statementByBuilderFromAncestor = semanticNetwork.DeclareThat(ancestor).IsAncestorOf(descendant);
var statementByBuilderFromDescendant = semanticNetwork.DeclareThat(descendant).IsDescendantOf(ancestor);
// assert
Assert.AreEqual(statementByConstuctor, statementByBuilderFromAncestor);
Assert.AreEqual(statementByConstuctor, statementByBuilderFromDescendant);
}
public void TestBuildingGroupStatement()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var area = ConceptCreationHelper.CreateConcept();
var concept = ConceptCreationHelper.CreateConcept();
// act
var statementByConstuctor = new GroupStatement(null, area, concept);
var statementByBuilderFromArea = semanticNetwork.DeclareThat(area).IsSubjectAreaOf(concept);
var statementByBuilderFromConcept = semanticNetwork.DeclareThat(concept).BelongsToSubjectArea(area);
// assert
Assert.AreEqual(statementByConstuctor, statementByBuilderFromArea);
Assert.AreEqual(statementByConstuctor, statementByBuilderFromConcept);
}
public void TestBuildingHasPartStatement()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var whole = ConceptCreationHelper.CreateConcept();
var part = ConceptCreationHelper.CreateConcept();
// act
var statementByConstuctor = new HasPartStatement(null, whole, part);
var statementByBuilderFromWhole = semanticNetwork.DeclareThat(whole).HasPart(part);
var statementByBuilderFromPart = semanticNetwork.DeclareThat(part).IsPartOf(whole);
// assert
Assert.AreEqual(statementByConstuctor, statementByBuilderFromWhole);
Assert.AreEqual(statementByConstuctor, statementByBuilderFromPart);
}
public void ExplainPreconditions()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var concept1 = ConceptCreationHelper.CreateConcept();
concept1.WithAttribute(IsValueAttribute.Value);
var concept2 = ConceptCreationHelper.CreateConcept();
concept2.WithAttribute(IsValueAttribute.Value);
var concept3 = ConceptCreationHelper.CreateConcept();
concept3.WithAttribute(IsValueAttribute.Value);
semanticNetwork.Concepts.Add(concept1);
semanticNetwork.Concepts.Add(concept2);
semanticNetwork.Concepts.Add(concept3);
var initialComparison = semanticNetwork.DeclareThat(concept1).IsEqualTo(concept2);
var preconditionComparison = new ComparisonStatement(null, concept2, concept3, ComparisonSigns.IsEqualTo);
// ... and do not add it to semantic network
// act
var answerWithoutPreconditions = semanticNetwork.Ask().HowCompared(concept1, concept3);
var answerWithPreconditions = semanticNetwork.Supposing(new IStatement[] { preconditionComparison }).Ask().HowCompared(concept1, concept3);
// assert
Assert.IsTrue(answerWithoutPreconditions.IsEmpty);
Assert.AreEqual(0, answerWithoutPreconditions.Explanation.Statements.Count);
Assert.IsFalse(answerWithPreconditions.IsEmpty);
var resultComparison = (ComparisonStatement)((StatementAnswer)answerWithPreconditions).Result;
Assert.AreSame(concept1, resultComparison.LeftValue);
Assert.AreSame(concept3, resultComparison.RightValue);
Assert.AreSame(ComparisonSigns.IsEqualTo, resultComparison.ComparisonSign);
Assert.AreEqual(2, answerWithPreconditions.Explanation.Statements.Count);
Assert.IsTrue(answerWithPreconditions.Explanation.Statements.Contains(initialComparison));
Assert.IsTrue(answerWithPreconditions.Explanation.Statements.Contains(preconditionComparison));
Assert.AreSame(initialComparison, semanticNetwork.Statements.Single());
}
public void ReturnTrueWithoutExplanationIfNoRelationships()
{
// arrange
var language = Language.Default;
var semanticNetwork = new TestSemanticNetwork(language).SemanticNetwork;
var concept = ConceptCreationHelper.CreateConcept();
concept.WithAttribute(IsValueAttribute.Value);
semanticNetwork.Concepts.Add(concept);
// act
var answer = semanticNetwork.Ask().IfIsValue(concept);
// assert
Assert.IsFalse(answer.IsEmpty);
Assert.IsTrue(((BooleanAnswer)answer).Result);
Assert.AreEqual(0, answer.Explanation.Statements.Count);
}
public void TestBuildingHasSignStatement()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var concept = ConceptCreationHelper.CreateConcept();
var sign = ConceptCreationHelper.CreateConcept();
sign.WithAttribute(IsSignAttribute.Value);
// act
var statementByConstuctor = new HasSignStatement(null, concept, sign);
var statementByBuilderFromConcept = semanticNetwork.DeclareThat(concept).HasSign(sign);
var statementByBuilderFromSign = semanticNetwork.DeclareThat(sign).IsSignOf(concept);
// assert
Assert.AreEqual(statementByConstuctor, statementByBuilderFromConcept);
Assert.AreEqual(statementByConstuctor, statementByBuilderFromSign);
}
public void TestBuildingComparisonStatement()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var leftValue = ConceptCreationHelper.CreateConcept();
leftValue.WithAttribute(IsValueAttribute.Value);
var rightValue = ConceptCreationHelper.CreateConcept();
rightValue.WithAttribute(IsValueAttribute.Value);
var statementsByConstuctor = new List <ComparisonStatement>();
var statementsByBuilder = new List <ComparisonStatement>();
// act
statementsByConstuctor.Add(new ComparisonStatement(null, leftValue, rightValue, ComparisonSigns.IsEqualTo));
statementsByBuilder.Add(semanticNetwork.DeclareThat(leftValue).IsEqualTo(rightValue));
statementsByConstuctor.Add(new ComparisonStatement(null, leftValue, rightValue, ComparisonSigns.IsNotEqualTo));
statementsByBuilder.Add(semanticNetwork.DeclareThat(leftValue).IsNotEqualTo(rightValue));
statementsByConstuctor.Add(new ComparisonStatement(null, leftValue, rightValue, ComparisonSigns.IsGreaterThan));
statementsByBuilder.Add(semanticNetwork.DeclareThat(leftValue).IsGreaterThan(rightValue));
statementsByConstuctor.Add(new ComparisonStatement(null, leftValue, rightValue, ComparisonSigns.IsGreaterThanOrEqualTo));
statementsByBuilder.Add(semanticNetwork.DeclareThat(leftValue).IsGreaterThanOrEqualTo(rightValue));
statementsByConstuctor.Add(new ComparisonStatement(null, leftValue, rightValue, ComparisonSigns.IsLessThan));
statementsByBuilder.Add(semanticNetwork.DeclareThat(leftValue).IsLessThan(rightValue));
statementsByConstuctor.Add(new ComparisonStatement(null, leftValue, rightValue, ComparisonSigns.IsLessThanOrEqualTo));
statementsByBuilder.Add(semanticNetwork.DeclareThat(leftValue).IsLessThanOrEqualTo(rightValue));
// assert
for (int s = 0; s < ComparisonSigns.All.Count; s++)
{
Assert.AreEqual(statementsByConstuctor[s], statementsByBuilder[s]);
}
}
public void CheckRecursivePaths()
{
var a = ConceptCreationHelper.CreateConcept();
var b = ConceptCreationHelper.CreateConcept();
var c = ConceptCreationHelper.CreateConcept();
var statementsValid1 = new IStatement[]
{
new TestPath(a, a),
};
var statementsValid2 = new IStatement[]
{
new TestPath(a, b),
new TestPath(b, a),
};
var statementsValid3 = new IStatement[]
{
new TestPath(a, b),
new TestPath(b, c),
new TestPath(c, a),
};
var statementsInvalid = new IStatement[]
{
new TestPath(a, b),
new TestPath(b, b),
};
var statementsValid4 = new IStatement[]
{
new TestPath(a, b),
new TestPath(b, c),
new TestPath(c, a),
};
foreach (var statements in new[] { statementsValid1, statementsValid2, statementsValid3, statementsValid4 })
{
Assert.IsTrue(statements.FindPath <IConcept>(typeof(TestPath), a, a).Any());
}
Assert.IsFalse(statementsInvalid.FindPath <IConcept>(typeof(TestPath), a, a).Any());
}
public void ReturnInheritedSignValue()
{
// arrange
var language = Language.Default;
var semanticNetwork = new TestSemanticNetwork(language);
var truck = ConceptCreationHelper.CreateConcept();
semanticNetwork.SemanticNetwork.Concepts.Add(truck);
var classification = semanticNetwork.SemanticNetwork.DeclareThat(truck).IsDescendantOf(semanticNetwork.Vehicle_Car);
// act
var answer = semanticNetwork.SemanticNetwork.Ask().WhatIsSignValue(truck, semanticNetwork.Sign_AreaType);
// assert
Assert.IsFalse(answer.IsEmpty);
Assert.AreSame(semanticNetwork.AreaType_Ground, ((ConceptAnswer)answer).Result);
Assert.AreEqual(2, answer.Explanation.Statements.Count);
Assert.IsTrue(answer.Explanation.Statements.Contains(classification));
Assert.AreEqual(1, answer.Explanation.Statements.OfType <SignValueStatement>().Count());
}
public void ReturnOverridenSignValue()
{
// arrange
var language = Language.Default;
var semanticNetwork = new TestSemanticNetwork(language);
var flyingCar = ConceptCreationHelper.CreateConcept();
semanticNetwork.SemanticNetwork.Concepts.Add(flyingCar);
semanticNetwork.SemanticNetwork.DeclareThat(flyingCar).IsDescendantOf(semanticNetwork.Vehicle_Car);
var newValue = semanticNetwork.SemanticNetwork.DeclareThat(semanticNetwork.AreaType_Air).IsSignValue(flyingCar, semanticNetwork.Sign_AreaType);
// act
var answer = semanticNetwork.SemanticNetwork.Ask().WhatIsSignValue(flyingCar, semanticNetwork.Sign_AreaType);
// assert
Assert.IsFalse(answer.IsEmpty);
Assert.AreSame(semanticNetwork.AreaType_Air, ((ConceptAnswer)answer).Result);
Assert.AreSame(newValue, answer.Explanation.Statements.Single());
}
public void TestBuildingPreconditions()
{
// arrange
var language = Language.Default;
var semanticNetwork = new TestSemanticNetwork(language);
var numberMinus1 = ConceptCreationHelper.CreateConcept();
numberMinus1.WithAttribute(IsValueAttribute.Value);
var precondition = new ComparisonStatement(null, numberMinus1, semanticNetwork.Number0, ComparisonSigns.IsLessThan);
var preconditions = new IStatement[] { precondition };
// act
var questionRegular = new ComparisonQuestion(numberMinus1, semanticNetwork.Number1, preconditions);
var answerRegular = (StatementAnswer)questionRegular.Ask(semanticNetwork.SemanticNetwork.Context);
var answerBuilder = (StatementAnswer)semanticNetwork.SemanticNetwork.Supposing(preconditions).Ask().HowCompared(numberMinus1, semanticNetwork.Number1);
// assert
Assert.AreEqual(answerRegular.Result, answerBuilder.Result);
Assert.IsTrue(answerRegular.Explanation.Statements.SequenceEqual(answerBuilder.Explanation.Statements));
}
public void FindWithTransition()
{
// arrange
var language = Language.Default;
var semanticNetwork = new TestSemanticNetwork(language);
var hugeAirbus = ConceptCreationHelper.CreateConcept();
semanticNetwork.SemanticNetwork.Concepts.Add(hugeAirbus);
var classification = semanticNetwork.SemanticNetwork.DeclareThat(hugeAirbus).IsDescendantOf(semanticNetwork.Vehicle_Airbus);
// act
var answer = semanticNetwork.SemanticNetwork.Ask().IfIs(hugeAirbus, semanticNetwork.Base_Vehicle);
//assert
Assert.IsFalse(answer.IsEmpty);
Assert.IsTrue(((BooleanAnswer)answer).Result);
Assert.AreEqual(2, answer.Explanation.Statements.Count);
Assert.AreEqual(2, answer.Explanation.Statements.OfType <IsStatement>().Count());
Assert.IsTrue(answer.Explanation.Statements.Contains(classification));
}
public void ReturnOwnSignsOnly()
{
// arrange
var language = Language.Default;
var semanticNetwork = new TestSemanticNetwork(language);
var ownSign = ConceptCreationHelper.CreateConcept();
ownSign.WithAttribute(IsSignAttribute.Value);
semanticNetwork.SemanticNetwork.Concepts.Add(ownSign);
var ownSignStatement = semanticNetwork.SemanticNetwork.DeclareThat(ownSign).IsSignOf(semanticNetwork.Vehicle_Motorcycle);
var question = new EnumerateSignsQuestion(semanticNetwork.Vehicle_Motorcycle, false);
// act
var answer = (ConceptsAnswer)question.Ask(semanticNetwork.SemanticNetwork.Context);
// assert
Assert.IsFalse(answer.IsEmpty);
Assert.AreSame(ownSign, answer.Result.Single());
Assert.AreSame(ownSignStatement, answer.Explanation.Statements.Single());
}
