void Initialize()
{
var ptA = new Pointf(0.0f, 1.0f);
var ptB = new Pointf(10.0f, 0.0f);
_ev = new SigmoidEvaluator(ptA, ptB, -0.5f);
}
void Initialize()
{
var ptA = new Pointf(0.0f, 1.0f);
var ptB = new Pointf(10.0f, 0.0f);
_ev = new PowerEvaluator(ptA, ptB, .5f);
}
public TaskState( NBTag tag )
{
if( FormatVersion != tag["FormatVersion"].GetInt() ) throw new FormatException( "Incompatible format." );
Shapes = tag["Shapes"].GetInt();
Vertices = tag["Vertices"].GetInt();
ImprovementCounter = tag["ImprovementCounter"].GetInt();
MutationCounter = tag["MutationCounter"].GetInt();
TaskStart = DateTime.UtcNow.Subtract( TimeSpan.FromTicks( tag["ElapsedTime"].GetLong() ) );
ProjectOptions = new ProjectOptions( tag["ProjectOptions"] );
BestMatch = new DNA( tag["BestMatch"] );
CurrentMatch = BestMatch;
Initializer = (IInitializer)ModuleManager.ReadModule( tag["Initializer"] );
Mutator = (IMutator)ModuleManager.ReadModule( tag["Mutator"] );
Evaluator = (IEvaluator)ModuleManager.ReadModule( tag["Evaluator"] );
byte[] imageBytes = tag["ImageData"].GetBytes();
using( MemoryStream ms = new MemoryStream( imageBytes ) ) {
OriginalImage = new Bitmap( ms );
}
var statsTag = (NBTList)tag["MutationStats"];
foreach( NBTag stat in statsTag ) {
MutationType mutationType = (MutationType)Enum.Parse( typeof( MutationType ), stat["Type"].GetString() );
MutationCounts[mutationType] = stat["Count"].GetInt();
MutationImprovements[mutationType] = stat["Sum"].GetDouble();
}
}
public EFQueryCache(IQueryCacheContainerMgr cacheContainerMgr, IEvaluator evaluator)
: base(cacheContainerMgr)
{
evaluator.CheckNull(nameof(evaluator));
_evaluator = evaluator;
}
public override void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder)
{
CommandCallList childCommands = commandCall.Children;
childCommands.SetUp(evaluator, resultRecorder);
childCommands.Execute(evaluator, resultRecorder);
childCommands.Verify(evaluator, resultRecorder);
String expression = commandCall.Expression;
Object result = evaluator.Evaluate(expression);
if (result != null && result is Boolean)
{
if ((Boolean) result)
{
ProcessTrueResult(commandCall, resultRecorder);
}
else
{
ProcessFalseResult(commandCall, resultRecorder);
}
}
else
{
throw new InvalidExpressionException("Expression '" + expression + "' did not produce a boolean result (needed for assertTrue).");
}
}
public ConfigurationDetails(IPredicate predicate, ISerializationProvider serializationProvider, ISourceDataProvider sourceDataProvider, IEvaluator evaluator)
{
_predicate = predicate;
_serializationProvider = serializationProvider;
_sourceDataProvider = sourceDataProvider;
_evaluator = evaluator;
}
public virtual void CalculateMetrics(FeatureSubsetModel <TOutput> model,
ISubsetSelector subsetSelector, Subset subset, Batch batch, bool needMetrics)
{
if (!needMetrics || model == null || model.Metrics != null)
{
return;
}
using (var ch = Host.Start("Calculate metrics"))
{
RoleMappedData testData = subsetSelector.GetTestData(subset, batch);
// Because the training and test datasets are drawn from the same base dataset, the test data role mappings
// are the same as for the train data.
IDataScorerTransform scorePipe = ScoreUtils.GetScorer(model.Predictor, testData, Host, testData.Schema);
RoleMappedData scoredTestData = new RoleMappedData(scorePipe,
GetColumnRoles(testData.Schema, scorePipe.Schema));
// REVIEW: Should we somehow allow the user to customize the evaluator?
// By what mechanism should we allow that?
IEvaluator evaluator = GetEvaluator(Host);
// REVIEW: with the new evaluators, metrics of individual models are no longer
// printed to the Console. Consider adding an option on the combiner to print them.
// REVIEW: Consider adding an option to the combiner to save a data view
// containing all the results of the individual models.
var metricsDict = evaluator.Evaluate(scoredTestData);
if (!metricsDict.TryGetValue(MetricKinds.OverallMetrics, out IDataView metricsView))
{
throw Host.Except("Evaluator did not produce any overall metrics");
}
// REVIEW: We're assuming that the metrics of interest are always doubles here.
var metrics = EvaluateUtils.GetMetrics(metricsView, getVectorMetrics: false);
model.Metrics = metrics.ToArray();
}
}
/// <summary>
/// Initialise a new instance of the GeneticEngine class with the supplied plug-ins and populate the initial generation.
/// </summary>
/// <param name="populator">The populator plug-in. Generates the initial population.</param>
/// <param name="evaluator">The evaluator plug-in. Provides the fitness function.</param>
/// <param name="geneticOperator">The genetic operator plug-in. Processes one generation to produce the individuals for the next.</param>
/// <param name="terminator">The terminator plug-in. Provides the termination condition.</param>
/// <param name="outputter">The outputter plug-in or null for no output. Outputs each generation.</param>
/// <param name="generationFactory">The generation factory plug-in or null to use the default. Creates the generation container.</param>
public GeneticEngine(IPopulator populator, IEvaluator evaluator, IGeneticOperator geneticOperator, ITerminator terminator, IOutputter outputter = null, IGenerationFactory generationFactory = null)
{
if (populator == null)
{
throw new GeneticEngineException("populator must not be null");
}
if (evaluator == null)
{
throw new GeneticEngineException("pvaluator must not be null");
}
if (geneticOperator == null)
{
throw new GeneticEngineException("geneticOperator must not be null");
}
if (terminator == null)
{
throw new GeneticEngineException("terminator must not be null");
}
this.populator = populator;
this.evaluator = evaluator;
this.geneticOperator = geneticOperator;
this.terminator = terminator;
this.outputter = outputter;
this.generationFactory = generationFactory == null ? new AATreeGenerationFactory() : generationFactory;
Setup();
}
public ConfigurationDetails(IPredicate predicate, ITargetDataStore serializationStore, ISourceDataStore sourceDataStore, IEvaluator evaluator)
{
_predicate = predicate;
_serializationStore = serializationStore;
_sourceDataStore = sourceDataStore;
_evaluator = evaluator;
}
public ValueStack(IExceptionHandler handler, IExpressionContext expressionContext)
{
Values = new CustomDictionary();
_exceptionHandler = handler;
_evaluator = expressionContext.CreateEvaluator(this);
Persistables = new Dictionary<string, IPersistable>();
}
public void TestMathModulo()
{
var xml = testXml.Of("TestMathModulo");
IEvaluator <int> func = engine.Create <int>(xml);
int rest = func.Evaluate(person);
Assert.AreEqual(8, rest);
}
public NSGA2(IReproduction <TChromosome> crossover,
IEvaluator <TChromosome> evaluator,
IReinsertion <TChromosome> reinsertion)
{
_crossover = crossover;
_evaluator = evaluator;
_reinsertion = reinsertion;
}
public static object DefaultEval(ArrayRef arrayRef, IEvaluator eval)
{
Array array = (Array)arrayRef.ArrayExpr.Eval(eval);
long[] indices = arrayRef.Indices.Select(i =>
TypeConversions.ToLong(i.Eval(eval))).ToArray();
return(array.GetValue(indices));
}
private JsonEasyRuleEvaluator(IMetricService metricService = null)
{
_easyRuleDymeRuleSvc = new EasyRuleDymeRuleConverter();
_worldAnalyser = new JsonPathWorldAnalyser();
_worldReader = new JsonPathWorldReader();
_inferenceEngineSvc = new DymeInferenceEvaluator(_worldReader, _worldAnalyser, metricService);
_ruleEvaluatorSvc = new DymeRuleEvaluator(_worldReader);
}
public SimplePlayer(IMoveFinder moveFinder, IEvaluator evaluator)
{
if (moveFinder == null) { throw new ArgumentNullException(nameof(moveFinder)); }
MoveFinder = moveFinder;
Evaluator = evaluator;
_numMovesTried = 0;
}
public ConfigurationDetails(IPredicate predicate, ITargetDataStore serializationStore, ISourceDataStore sourceDataStore, IEvaluator evaluator, ConfigurationDependencyResolver dependencyResolver)
{
_predicate = predicate;
_serializationStore = serializationStore;
_sourceDataStore = sourceDataStore;
_evaluator = evaluator;
_dependencyResolver = dependencyResolver;
}
public void Init()
{
PaytableBuilder builder = new PickPaytableBuilder();
pickEvaluator = new PickEvaluator("Pick Feature");
paytable = new Paytable();
paytable.PickTableGroup = builder.BuildPickTableGroup();
}
// Start is called before the first frame update
void Start()
{
InitBoard();
gameExecutor = new GameExecutor(board, DisplayBoard);
boardEvaluator = new ColumnGameEvaluator(5);
DisplayBoard();
}
public void TestDirectCallOfRegex()
{
var xml = testXml.Of("TestDirectCallOfRegex");
IEvaluator <int> func = engine.Create <int>(xml);
int result = func.Evaluate(person);
Assert.AreEqual(3, result);
}
public void TestOptimisticLambda()
{
var xml = testXml.Of("TestOptimisticLambda");
IEvaluator <Person> func = engine.Create <Person>(xml);
Person relative = func.Evaluate(person);
Assert.AreEqual("Katya", relative.Name);
}
public void TestMathAdd()
{
var xml = testXml.Of("TestMathAdd");
IEvaluator <int> func = engine.Create <int>(xml);
int count = func.Evaluate(person);
Assert.AreEqual(2000, count);
}
public AppController(IHostingEnvironment env, IConfigurationRoot config, ILoggerFactory loggerFactory, IAppRepository repository, IEvaluator evaluator)
{
_hostingEnv = env;
_config = config;
_repository = repository;
_evaluator = evaluator;
_logger = loggerFactory.CreateLogger("AppController");
}
public void TestLambdaScalarCount()
{
var xml = testXml.Of("TestLambdaScalarCount");
IEvaluator <int> func = engine.Create <int>(xml);
int count = func.Evaluate(person);
Assert.AreEqual(2, count);
}
public ConfigurationDetails(IPredicate predicate, ITargetDataStore serializationStore, ISourceDataStore sourceDataStore, IEvaluator evaluator, ConfigurationDependencyResolver dependencyResolver)
{
_predicate = predicate;
_serializationStore = serializationStore;
_sourceDataStore = sourceDataStore;
_evaluator = evaluator;
_dependencyResolver = dependencyResolver;
}
public void TestCallOfStaticMethod()
{
var xml = testXml.Of("TestCallOfStaticMethod");
IEvaluator <string> func = engine.Create <string>(xml);
string result = func.Evaluate(person);
Assert.AreEqual("My name is Alexander", result);
}
public ForNode(IEvaluator from, string key, string value, INode body, INode empty)
{
this.body = body;
this.empty = empty;
this.from = from;
this.key = key;
this.value = value;
}
public ConfigurationDetails(IPredicate predicate, ITargetDataStore serializationStore, ISourceDataStore sourceDataStore, IEvaluator evaluator, ISerializationFormatter formatter)
{
_predicate = predicate;
_serializationStore = serializationStore;
_sourceDataStore = sourceDataStore;
_evaluator = evaluator;
_formatter = formatter;
}
public void TestCallOfInstanceMethod()
{
var xml = testXml.Of("TestCallOfInstanceMethod");
IEvaluator <string> func = engine.Create <string>(xml);
string relationship = func.Evaluate(person);
Assert.AreEqual("Alexander + Katya", relationship);
}
public SpfEvaluationProcessor(IEvaluator <SpfRecord> evaluator,
ISpfRecordExplainer recordExplainer,
ISpfRecordsJobsProcessor spfRecordsJobsProcessor)
{
_evaluator = evaluator;
_recordExplainer = recordExplainer;
_spfRecordsJobsProcessor = spfRecordsJobsProcessor;
}
/// <summary>
/// Initializes a new instance of the <see cref="Condition"/> class.
/// </summary>
/// <param name="label">The label.</param>
public Condition(string label)
{
_label = label;
_subconditions = new List<LeftHandSideCondition>();
_conditionType = ConditionType.Positive;
_fields = new Term[3];
_evaluator = new Equals();
}
public AlphaBetaAlgorithm(IEvaluator <TState> evaluator, IGenerator <TState, TMove> moveGenerator,
IApplier <TState, TMove> applier)
{
_evaluator = evaluator;
_moveGenerator = moveGenerator;
_moveApplier = applier;
_maxDepth = 3;
}
public ParallelMiniMax(IGame game, Color color, IEvaluator evaluator, IMoveSorter moveSorter, int depth)
{
this.game = game;
this.color = color;
this.evaluator = evaluator;
this.moveSorter = moveSorter;
Depth = depth;
}
public ConfigurationDetails(IPredicate predicate, ISerializationProvider serializationProvider, ISourceDataProvider sourceDataProvider, IEvaluator evaluator, ISitecoreSerializationFormatter formatter)
{
_predicate = predicate;
_serializationProvider = serializationProvider;
_sourceDataProvider = sourceDataProvider;
_evaluator = evaluator;
_formatter = formatter;
}
public ForNode(IEvaluator from, string key, string value, INode body, INode empty)
{
this.body = body;
this.empty = empty;
this.from = from;
this.key = key;
this.value = value;
}
public void TestBlockAndRegex()
{
var xml = testXml.Of("TestBlockAndRegex");
IEvaluator <int> func = engine.Create <int>(xml);
int count = func.Evaluate(person);
Assert.AreEqual(1, count);
}
/// <summary>
/// Initializes a new instance of the <see cref="Condition"/> class.
/// </summary>
/// <param name="label">The label.</param>
public Condition(string label)
{
_label = label;
_subconditions = new List <LeftHandSideCondition>();
_conditionType = ConditionType.Positive;
_fields = new Term[3];
_evaluator = new Equals();
}
public NSGA2(IReproduction <TChromosome> crossover,
IReproduction <TChromosome> mutation,
IEvaluator <TChromosome> evaluator,
IReinsertion <TChromosome> reinsertion) :
this(crossover, evaluator, reinsertion)
{
_mutation = mutation;
}
void calcColumn(DataRow pRow, string pCol)
{
IEvaluator eval = evals[Array.IndexOf <string>(columnsCalc, pCol)];
object[] vals = ToolRow.copyRowToArr(columnsVars, pRow);
eval.setVarAll(vals);
ToolCell.set(pRow, pCol, eval.getResult());
}
public Trainer(int nb_inputs, int[] nb_neurons_layer, int population_size, IEvaluator evaluator)
{
this.population = new List<DNA>();
for(int i = 0; i < population_size; i++)
{
this.population.Add (new DNA(nb_inputs, nb_neurons_layer));
}
this.evaluator = evaluator;
}
public GenericToggleAction(ILogger <GenericToggleAction> logger, IFlightConnector flightConnector, IImageLogic imageLogic,
IEvaluator evaluator, EnumConverter enumConverter)
{
this.logger = logger;
this.flightConnector = flightConnector;
this.imageLogic = imageLogic;
this.evaluator = evaluator;
this.enumConverter = enumConverter;
}
public void Setup()
{
IEvaluator evaluator = Evaluator;
var setupMethods = evaluator.GetType().GetMethods()
.Where(m =>
m.GetCustomAttributes(typeof(SetupAttribute), false).Length > 0);
evaluator.Setup();
}
public LtcService(IEventLogger eventLogger, IUserUnloger userUnloger, IOsUsersReader osUsersReader, IEvaluator evaluator)
{
InitializeComponent();
Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
_notAdminUserLoggedIn = false;
_eventLogger = eventLogger;
_userUnloger = userUnloger;
_osUsersReader = osUsersReader;
_evaluator = evaluator;
}
private static double[] Evaluate(IEvaluator evaluator, Function[] functions)
{
List<double> values = new List<double>();
foreach (Function function in functions)
{
values.Add(evaluator.Evaluate(function));
}
return values.ToArray();
}
private void increaseLevel(IEvaluator evaluator)
{
if (evaluator.GetVariable(LEVEL_VARIABLE) == null)
{
evaluator.SetVariable(LEVEL_VARIABLE, 1);
}
else
{
evaluator.SetVariable(LEVEL_VARIABLE, 1 + (int)evaluator.GetVariable(LEVEL_VARIABLE));
}
}
public void SetupFixBuzProtoForTest()
{
IEnumerable<int> list = Enumerable.Range(0, 16);
List<ValueTokenPair<int, string>> pairs = new List<ValueTokenPair<int, string>> {
new ValueTokenPair<int, string> {Value=3, Token=fiz},
new ValueTokenPair<int, string> {Value=5, Token=buz}
};
caster = new IntToStringCaster();
evaluator = new DivisorEvaluator();
listEvaler = new ListEvaluator<int, int, string>(list, pairs, caster, evaluator);
}
public override void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder)
{
try
{
m_command.Execute(commandCall, evaluator, resultRecorder);
}
catch (Exception e)
{
resultRecorder.Record(Result.Exception);
OnExceptionCaught(commandCall.Element, e, commandCall.Expression);
}
}
public override void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder)
{
try
{
m_command.Verify(commandCall, evaluator, resultRecorder);
}
catch (Exception e)
{
resultRecorder.Record(Result.Exception);
AnnounceThrowableCaught(commandCall.Element, e, commandCall.Expression);
}
}
public override void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder)
{
try
{
m_command.Execute(commandCall, evaluator, resultRecorder);
}
catch (Exception e)
{
resultRecorder.Error(e);
AnnounceThrowableCaught(commandCall.Element, e, commandCall.Expression);
}
}
public void Process(IUrlParser parser, IEvaluator evaluator)
{
if (parser == null) throw new ArgumentNullException("parser");
if (evaluator == null) throw new ArgumentNullException("evaluator");
var words = parser.Parse(_url);
var buzzwords = words.Where(evaluator.IsBuzzword);
foreach (var buzzword in buzzwords)
{
ApplyEvent(new BuzzwordFoundEvent(buzzword));
}
}
public override void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder)
{
Check.IsFalse(commandCall.HasChildCommands, "Nesting commands inside a 'run' is not supported");
var element = commandCall.Element;
var href = element.GetAttributeValue("href");
Check.NotNull(href, "The 'href' attribute must be set for an element containing concordion:run");
var runnerType = commandCall.Expression;
var expression = element.GetAttributeValue("params", "concordion");
if (expression != null)
{
evaluator.Evaluate(expression);
}
try
{
IRunner concordionRunner;
Runners.TryGetValue(runnerType, out concordionRunner);
// TODO - re-check this.
Check.NotNull(concordionRunner, "The runner '" + runnerType + "' cannot be found. "
+ "Choices: (1) Use 'concordion' as your runner (2) Ensure that the 'concordion.runner." + runnerType
+ "' System property is set to a name of an IRunner implementation "
+ "(3) Specify an assembly fully qualified class name of an IRunner implementation");
var result = concordionRunner.Execute(evaluator.Fixture, commandCall.Resource, href).Result;
if (result == Result.Success)
{
resultRecorder.Success();
AnnounceSuccess(element);
}
else if (result == Result.Ignored)
{
resultRecorder.Ignore();
AnnounceIgnored(element);
}
else
{
resultRecorder.Failure(string.Format("test {0} failed", href), commandCall.Element.ToXml());
AnnounceFailure(element);
}
}
catch (Exception e)
{
resultRecorder.Error(e);
AnnounceError(e, element, expression);
}
}
public void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder)
{
IExecuteStrategy strategy;
if (commandCall.Element.IsNamed("table"))
{
strategy = new TableExecuteStrategy();
}
else
{
strategy = new DefaultExecuteStrategy();
}
strategy.Execute(commandCall, evaluator, resultRecorder);
}
public void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder)
{
var pattern = new Regex("(#.+?) *: *(.+)");
var matcher = pattern.Match(commandCall.Expression);
if (!matcher.Success)
{
throw new InvalidOperationException("The expression for a \"verifyRows\" should be of the form: #var : collectionExpr");
}
var loopVariableName = matcher.Groups[1].Value;
var iterableExpression = matcher.Groups[2].Value;
var obj = evaluator.Evaluate(iterableExpression);
Check.NotNull(obj, "Expression returned null (should be an IEnumerable).");
Check.IsTrue(obj is IEnumerable, obj.GetType() + " is not IEnumerable");
Check.IsTrue(!(obj is IDictionary), obj.GetType() + " does not have a predictable iteration order");
var iterable = (IEnumerable)obj;
var tableSupport = new TableSupport(commandCall);
var detailRows = tableSupport.GetDetailRows();
AnnounceExpressionEvaluated(commandCall.Element);
int index = 0;
foreach (var loopVar in iterable)
{
evaluator.SetVariable(loopVariableName, loopVar);
Row detailRow;
if (detailRows.Count > index)
{
detailRow = detailRows[index];
}
else
{
detailRow = tableSupport.AddDetailRow();
AnnounceSurplusRow(detailRow.RowElement);
}
tableSupport.CopyCommandCallsTo(detailRow);
commandCall.Children.Verify(evaluator, resultRecorder);
index++;
}
for (; index < detailRows.Count; index++) {
Row detailRow = detailRows[index];
resultRecorder.Record(Result.Failure);
AnnounceMissingRow(detailRow.RowElement);
}
}
public SerializationLoader(ITargetDataStore targetDataStore, ISourceDataStore sourceDataStore, IPredicate predicate, IEvaluator evaluator, ISerializationLoaderLogger logger, PredicateRootPathResolver predicateRootPathResolver)
{
Assert.ArgumentNotNull(targetDataStore, "serializationProvider");
Assert.ArgumentNotNull(sourceDataStore, "sourceDataStore");
Assert.ArgumentNotNull(predicate, "predicate");
Assert.ArgumentNotNull(evaluator, "evaluator");
Assert.ArgumentNotNull(logger, "logger");
Assert.ArgumentNotNull(predicateRootPathResolver, "predicateRootPathResolver");
Logger = logger;
PredicateRootPathResolver = predicateRootPathResolver;
Evaluator = evaluator;
Predicate = predicate;
TargetDataStore = targetDataStore;
SourceDataStore = sourceDataStore;
}
public override void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder)
{
object savedTextValue = evaluator.GetVariable(TEXT_VARIABLE);
object savedHrefValue = evaluator.GetVariable(HREF_VARIABLE);
try
{
evaluator.SetVariable(TEXT_VARIABLE, commandCall.Element.Text);
evaluator.SetVariable(HREF_VARIABLE, getHref(commandCall.Element));
m_command.Verify(commandCall, evaluator, resultRecorder);
}
finally
{
evaluator.SetVariable(TEXT_VARIABLE, savedTextValue);
evaluator.SetVariable(HREF_VARIABLE, savedHrefValue);
}
}
protected override double ComputeValue(IEvaluator evaluator)
{
double x = f.Value(evaluator);
if (x < 0.0)
{
return -1.0;
}
else if (x > 0.0)
{
return 1.0;
}
else
{
// Not defined at zero.
return double.NaN;
}
}
public SerializationLoader(ISourceDataStore sourceDataStore, ITargetDataStore targetDataStore, IPredicate predicate, IEvaluator evaluator, ISerializationLoaderLogger logger, ISyncConfiguration syncConfiguration, PredicateRootPathResolver predicateRootPathResolver)
{
Assert.ArgumentNotNull(targetDataStore, nameof(targetDataStore));
Assert.ArgumentNotNull(sourceDataStore, nameof(sourceDataStore));
Assert.ArgumentNotNull(predicate, nameof(predicate));
Assert.ArgumentNotNull(evaluator, nameof(evaluator));
Assert.ArgumentNotNull(logger, nameof(logger));
Assert.ArgumentNotNull(predicateRootPathResolver, nameof(predicateRootPathResolver));
Assert.ArgumentNotNull(syncConfiguration, nameof(syncConfiguration));
Logger = logger;
SyncConfiguration = syncConfiguration;
PredicateRootPathResolver = predicateRootPathResolver;
Evaluator = evaluator;
Predicate = predicate;
TargetDataStore = targetDataStore;
SourceDataStore = sourceDataStore;
}
public void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder)
{
increaseLevel(evaluator);
ListSupport listSupport = new ListSupport(commandCall);
foreach (ListEntry listEntry in listSupport.GetListEntries())
{
commandCall.Element = listEntry.Element;
if (listEntry.IsItem)
{
commandCall.Execute(evaluator, resultRecorder);
}
if (listEntry.IsList)
{
Execute(commandCall, evaluator, resultRecorder);
}
}
decreaseLevel(evaluator);
}
public void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder)
{
Check.IsFalse(commandCall.HasChildCommands, "Nesting commands inside an 'echo' is not supported");
Object result = evaluator.Evaluate(commandCall.Expression);
Element element = commandCall.Element;
if (result != null)
{
element.AppendText(result.ToString());
}
else
{
Element child = new Element("em");
child.AppendText("null");
element.AppendChild(child);
}
}
public void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder)
{
Check.IsFalse(commandCall.HasChildCommands, "Nesting commands inside an 'assertEquals' is not supported");
Element element = commandCall.Element;
object actual = evaluator.Evaluate(commandCall.Expression);
string expected = element.Text;
if (m_comparer.Compare(actual, expected) == 0)
{
resultRecorder.Record(Result.Success);
OnSuccessReported(element);
}
else
{
resultRecorder.Record(Result.Failure);
OnFailureReported(element, actual, expected);
}
}
public override void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder)
{
Check.IsFalse(commandCall.HasChildCommands, "Nesting commands inside an 'assertEquals' is not supported");
Element element = commandCall.Element;
object actual = evaluator.Evaluate(commandCall.Expression);
string expected = element.Text;
if (this.m_Comparer.Compare(actual, expected) == 0)
{
resultRecorder.Success();
AnnounceSuccess(element);
}
else
{
resultRecorder.Failure(string.Format("expected {0} but was {1}", expected, actual),
element.ToXml());
AnnounceFailure(element, expected, actual);
}
}