public void DerivationOnlyNecessaryFactsTestCase()
{
int counter = 0;
const int expectedValue = 5;
var container = new Container
{
new Input16Fact(0),
new Input15Fact(0),
};
GivenCreateFactFactory()
.AndRulesNotNul()
.AndAddRules(new Collection
{
// main rule.
(Input2Fact f) =>
{
counter++;
return(new Input1Fact(f.Value + 1));
}
})
.AndAddRules(new Collection
{
// way.
(Input8Fact f) =>
{
counter++;
return(new Input2Fact(f.Value + 1));
},
(Input9Fact f) =>
{
counter++;
return(new Input8Fact(f.Value + 1));
},
(Input10Fact f) =>
{
counter++;
return(new Input9Fact(f.Value + 1));
},
(Input16Fact f) =>
{
counter++;
return(new Input10Fact(f.Value + 1));
},
})
.AndAddRules(new Collection
{
// another rule to output the penultimate fact.
(Input8Fact f) =>
{
counter++;
return(new Input10Fact(f.Value + 1));
}
})
.When("Derive facts.", factFactory =>
factFactory.DeriveFact <Input1Fact>(container))
.Then("Check result.", _ =>
Assert.AreEqual(expectedValue, counter, "It had to work out 5 rules"))
.Run();
}
public void DerivedThreeFactsTestCase()
{
Input6Fact input6Fact = null;
Input16Fact input16Fact = null;
Input7Fact input7Fact = null;
var container = new Container
{
new Input3Fact(3),
};
GivenCreateFactFactory()
.AndAddRules(RuleCollectionHelper.GetInputFactRules())
.And("Want fact6.", factory =>
factory.WantFacts((Input6Fact fact) => { input6Fact = fact; }, container))
.And("Want fact16.", factory =>
factory.WantFacts((Input16Fact fact) => { input16Fact = fact; }, container))
.And("Want fact16.", factory =>
factory.WantFacts((Input7Fact fact) => { input7Fact = fact; }, container))
.When("Derive facts.", factory =>
factory.Derive())
.Then("Check error.", _ =>
{
Assert.IsNotNull(input6Fact, "input6Fact is not derived");
Assert.IsNotNull(input16Fact, "input16Fact is not derived");
Assert.IsNotNull(input7Fact, "input7Fact is not derived");
})
.Run();
}
public void AddFactWithoutWriterTestCase()
{
var container = new Container();
container.IsReadOnly = true;
GivenEmpty()
.When("Add fact.", () =>
ExpectedFactFactoryException(() => container.Add(new IntFact(default))))
public void ContainerCannotBeNullTestCase()
{
const string expectedReason = "Container cannot be null.";
Container container = null;
GivenCreateFacade()
.When("Run method ValidateAndGetRules.", facade =>
ExpectedDeriveException(() => facade.ValidateContainer(container)))
.ThenAssertErrorDetail(ErrorCode.InvalidData, expectedReason)
.Run();
}
public void GetFactFromContainerTastCase()
{
var input6Fact = new Input6Fact(6);
var container = new Container
{
input6Fact,
};
GivenCreateFactFactory()
.When("Derive fact.", factFactory =>
factFactory.DeriveFact <Input6Fact>(container))
.ThenAreEqual(input6Fact)
.Run();
}
public void DeriveFactTestCase()
{
const int expectedValue = 10;
var container = new Container
{
new Input10Fact(expectedValue),
};
GivenCreateFactFactory()
.When("Run DeriveFact.", factFactory =>
factFactory.DeriveFact <Input10Fact>(container))
.ThenFactValueEquals(expectedValue)
.Run();
}
public void ContainerContainRuntimeConditionFactTestCase()
{
const string expectedReason = "Container contains IRuntimeConditionFact facts.";
Container container = new Container
{
new RCanDerived <DefaultFact>()
};
GivenCreateFacade()
.When("Run method ValidateAndGetRules.", facade =>
ExpectedDeriveException(() => facade.ValidateContainer(container)))
.ThenAssertErrorDetail(ErrorCode.InvalidData, expectedReason)
.Run();
}
//[Timeout(Timeouts.Millisecond.FiveHundred)]
public void ChoosingShortestWayTestCase()
{
const int expectedValue = 5;
var container = new Container
{
new Input16Fact(0),
};
GivenCreateFactFactory()
.AndRulesNotNul()
.AndAddRules(new Collection
{
// main rule.
(Input2Fact f) => new Input1Fact(f + 1),
})
.AndAddRules(new Collection
{
// 1 way.
(Input3Fact f) => new Input2Fact(f + 1),
(Input4Fact f) => new Input3Fact(f + 1),
(Input5Fact f) => new Input4Fact(f + 1),
(Input6Fact f) => new Input5Fact(f + 1),
(Input7Fact f) => new Input6Fact(f + 1),
(Input16Fact f) => new Input7Fact(f + 1),
})
.AndAddRules(new Collection
{
// 2 way.
(Input8Fact f) => new Input2Fact(f + 1),
(Input9Fact f) => new Input8Fact(f + 1),
(Input10Fact f) => new Input9Fact(f + 1),
(Input16Fact f) => new Input10Fact(f + 1),
})
.AndAddRules(new Collection
{
// 3 way.
(Input11Fact f) => new Input2Fact(f + 1),
(Input12Fact f) => new Input11Fact(f + 1),
(Input13Fact f) => new Input12Fact(f + 1),
(Input14Fact f) => new Input13Fact(f + 1),
(Input16Fact f) => new Input14Fact(f + 1),
})
.When("Derive facts.", factFactory =>
factFactory.DeriveFact <Input1Fact>(container))
.ThenFactValueEquals(expectedValue)
.Run();
}
public void CreateResultFactIfInput1FactContainedTestCase()
{
const int expectedValue = 1;
var container = new Container
{
new Input1Fact(expectedValue),
};
GivenCreateFactFactory()
.AndAddRules(new Collection
{
(BuildContained <Input1Fact> _, Input1Fact fact) => new ResultFact(fact.Value),
(BuildNotContained <Input1Fact> _) => new ResultFact(-1),
})
.When("Derive.", factFactory =>
factFactory.DeriveFact <ResultFact>(container))
.ThenFactValueEquals(expectedValue)
.Run();
}
public void UseHigherPriorityRightTestCase()
{
const long expectedValue = 2;
var container = new Container
{
new Fact1(1),
};
GivenCreateFactFactory()
.AndAddRules(new Collection
{
(Priority2 p, Fact1 f) => new FactResult(f),
(Priority1 p, Fact1 f) => new FactResult(f + p),
})
.When("Derive fact.", factory =>
factory.DeriveFact <FactResult>(container))
.ThenIsNotNull()
.AndAreEqual(fact => fact.Value, expectedValue)
.Run();
}
public void DeriveWithBuildCannotDerivedTestCase()
{
const int value = 14;
const int expectedValue = 37;
var container = new Container
{
new Input14Fact(value),
};
GivenCreateFactFactory()
.AndRulesNotNul()
.AndAddRules(new Collection
{
(Input12Fact fact) => new Input11Fact(fact.Value + 11),
(Input14Fact fact, BuildCannotDerived <Input9Fact> no) => new Input12Fact(fact.Value + 12),
(Input8Fact fact) => new Input9Fact(fact.Value + 12)
})
.When("Derive.", factory =>
factory.DeriveFact <Input11Fact>(container))
.ThenFactValueEquals(expectedValue)
.Run();
}
public void DeriveFactsAfterRunDeriveFactTestCase()
{
Input6Fact fact6 = null;
Input16Fact fact16 = null;
Input7Fact fact7 = null;
GetcuReone.FactFactory.FactFactory factory = null;
var container = new Container();
GivenCreateFactFactory()
.AndAddRules(new Collection
{
() => new Input6Fact(6),
() => new Input16Fact(16),
() => new Input7Fact(7),
})
.And("Want facts.", factFactory =>
{
factFactory.WantFacts((Input6Fact fact) => fact6 = fact, container);
factFactory.WantFacts((Input16Fact fact) => fact16 = fact, container);
factFactory.WantFacts((Input7Fact fact) => fact7 = fact, container);
factory = factFactory;
})
.And("Derive fact.", factFactory =>
factFactory.DeriveFact <Input7Fact>(container))
.When("Derive facts", fact =>
{
factory.Derive();
})
.Then("Check Input7Fact.", fact => Assert.AreEqual(fact, fact7))
.And("Check result.", _ =>
{
Assert.IsNotNull(fact7, "fact7 must derived");
Assert.IsNotNull(fact16, "fact16 must derived");
Assert.IsNotNull(fact6, "fact6 must derived");
})
.Run();
}
public async Task RunningAsynchronousRulesInParallelWithFactConditionsTestCase()
{
const int expectedValue = 16;
var container = new Container
{
new Input1Fact(1),
};
await GivenCreateFactFactory()
.AndAddRules(new Collection
{
{
async(Input1Fact fact, BuildContained <Input1Fact> _) =>
{
return(await Task.Run(() => new Input6Fact(fact * 6)));
},
FactWorkOption.CanExecuteAsync | FactWorkOption.CanExcecuteParallel
},
{
async(Input1Fact fact, BuildContained <Input1Fact> _) =>
{
return(await Task.Run(() => new Input10Fact(fact * 10)));
},
FactWorkOption.CanExecuteAsync | FactWorkOption.CanExcecuteParallel
},
{
async(Input6Fact fact6, Input10Fact fact10) =>
{
return(await Task.Run(() => new Input16Fact(fact6 + fact10)));
},
FactWorkOption.CanExecuteAsync | FactWorkOption.CanExcecuteParallel
}
})
.WhenAsync("Derive.", factory => factory.DeriveFactAsync <Input16Fact>(container))
.ThenFactValueEquals(expectedValue)
.RunAsync();
}
public void Initialize()
{
Container = new Container();
WantAction = GetWantAction((ResultFact _) => { });
}
public virtual void Initialize()
{
Container = new Container(GetVersionFacts());
WantAction = GetWantAction((FactResult f) => { });
}
public void Initialize()
{
Container = new Container
{
new Input1Fact(default),
