public void Call_For_Data_When_Constructed()
{
// Arrange
var dataReader = new FakeReader();
var viewModel = new SidebarViewModel(dataReader);
// Assert
Assert.AreEqual(true, viewModel.FetchDataOnConstruction);
}
public void FewInt() => TimeRunner.Run(async(time, th) =>
{
var reader = new FakeReader <int>(th)
{
0, 1, 2, 3
};
using (var db = new Db <int>(th, reader, disableWatch: true))
{
await db.InitialiseTask.ConfigureAwait(th);
Assert.Equal(new [] { 2, 3 }, db.Where(x => x >= 2).ToImmutableArray());
}
});
public void FilterStockSymbols_Are_Filtered()
{
//Arrange
IStockReader dataReader = new FakeReader();
SidebarViewModel viewModel = new SidebarViewModel(dataReader);
//Act
viewModel.FilterStockSymbols("abb");
//Assert
Assert.IsNotNull(viewModel.FilteredStocks);
}
public void SidebarViewModel_onStart_Gets_FilteredStocks()
{
// Arrange
IStockReader dataReader = new FakeReader();
SidebarViewModel viewModel = new SidebarViewModel(dataReader);
Thread.Sleep(1000);
// Assert
Assert.IsNotNull(viewModel.FilteredStocks);
Assert.AreEqual(2, viewModel.FilteredStocks.Count);
}
public void Stocks_loaded_when_class_constructed()
{
// Arrange
var reader = new FakeReader();
var viewModel = new StockViewViewModel("abb", reader);
// Act
Thread.Sleep(1000);
// Assert
Assert.IsNotNull(viewModel.Stock);
}
public void FirstOrDefault() => TimeRunner.Run(async(time, th) =>
{
var reader = new FakeReader <int>(th)
{
0, 1, 2, 3
};
using (var db = new Db <int>(th, reader))
{
await db.InitialiseTask.ConfigureAwait(th);
Assert.Equal(0, db.FirstOrDefault());
Assert.Null(db.Take(0).FirstOrDefault());
}
});
public void Read_CorrectValuesDataAndCountValuesNoEquals3_ThrowInvalidDataFotParametersException(string dataLine1, string dataLine2, string dataLine3)
{
// arrange
var data = new List <string> {
dataLine1, dataLine2, dataLine3
};
var fakeReader = new FakeReader(data);
// act and assert
Assert.Catch <InvalidDataFotParametersException>(() =>
{
fakeReader.Read();
});
}
public void Read_InvalidData_ThrowInvalidDataFotParametersException(string dataLine)
{
// arrange
var data = new List <string> {
dataLine
};
var fakeReader = new FakeReader(data);
// act and assert
Assert.Catch <InvalidDataFotParametersException>(() =>
{
fakeReader.Read();
});
}
public void ShouldPrintOutGameOverAndWaitForInput()
{
//Arrange
FakeWriter fakeWriter = new FakeWriter();
FakeReader fakeReader = new FakeReader(Environment.NewLine);
ConsoleGameEnding subject = new ConsoleGameEnding(fakeReader, fakeWriter);
//Act
subject.Display();
//Assert
fakeWriter.AssertLinesWritten("Game over", "Press Enter to Exit");
fakeReader.AssertReadLineInvoked();
}
public void SettingsSourceAllowsResolvingOfSettingClasses()
{
var builder = new ContainerBuilder();
var reader = new FakeReader();
builder.RegisterInstance(reader).As<ISettingsReader>();
builder.RegisterSource(new SettingsSource());
var container = builder.Build();
var fakeSettings = new FakeSettings();
reader.Settings = fakeSettings;
var resolvedSettings = container.Resolve<FakeSettings>();
Assert.AreSame(fakeSettings, resolvedSettings);
Assert.IsTrue(reader.WasCalled);
}
public void Read_CorrectData_DoesNotThrowCorrectParameters(string dataLine, double a, double b, double c)
{
// arrange
var data = new List <string> {
dataLine
};
var fakeReader = new FakeReader(data);
// act
var paramsEquation = fakeReader.Read().First();
// assert
Assert.AreEqual(a, paramsEquation.A);
Assert.AreEqual(b, paramsEquation.B);
Assert.AreEqual(c, paramsEquation.C);
}
public void ShouldRunFirstValidInput()
{
//Arrange
FakeRegexBookEnd fakeRegexBookEnd = new FakeRegexBookEnd.Builder().IsMatch(Bool.True).Build();
FakeWriter fakeWriter = new FakeWriter();
FakeReader fakeReader = new FakeReader("A", "B", "C");
FakeValidInputResponseAction <string> fakeValidInputResponseAction = new FakeValidInputResponseAction <string> .Builder().Response("A").Build();
ValidResponse <string> subject = new ValidResponse <string>(fakeRegexBookEnd, new[] { "", "", "" }, fakeValidInputResponseAction, fakeWriter, fakeReader);
//Act
string input = subject.Response();
//Assert
fakeRegexBookEnd.AssertIsMatchInvokedCountMatches(1);
fakeValidInputResponseAction.AssertResponseInvokedWith("A");
}
public void SettingsSourceAllowsResolvingOfSettingClasses()
{
var builder = new ContainerBuilder();
var reader = new FakeReader();
var injector = new FakeInjector();
builder.RegisterInstance(reader).As<ISettingsReader>();
builder.RegisterInstance(injector).As<ISettingsInjector>();
builder.RegisterSource(new SettingsSource());
var container = builder.Build();
var fakeSettings = new NameValueCollection();
reader.Collection = fakeSettings;
var resolvedSettings = container.Resolve<FakeSettings>();
Assert.IsNotNull(resolvedSettings);
Assert.IsTrue(injector.WasCalled);
Assert.IsNotNull(injector.Settings, "Settings sources were not passed to injector");
Assert.IsTrue(injector.Settings.Contains(reader));
}
public override OracleTableJournal Given()
{
dbConnection = Substitute.For <IDbConnection>();
dbCommand = Substitute.For <IDbCommand>();
dbCommand.ExecuteScalar().Returns(1);
log = new CaptureLogsLogger();
var table = new DataTable();
table.Columns.Add("column", Type.GetType("System.String"));
var row = table.NewRow();
row["column"] = "id";
table.Rows.Add(row);
var fakeReader = new FakeReader(table);
dbCommand.ExecuteReader().Returns(fakeReader);
dbConnection.CreateCommand().Returns(dbCommand);
var connectionManager = new TestConnectionManager(dbConnection);
var versionTracker = new OracleTableJournal(() => connectionManager, () => log, null, "history");
return(versionTracker);
}
/// <summary>
/// Fills a <c>Map</c> with <see cref="WeightedSpanTerm"/>s using the terms from the supplied <c>Query</c>.
/// </summary>
/// <param name="query">Query to extract Terms from</param>
/// <param name="terms">Map to place created WeightedSpanTerms in</param>
private void Extract(Query query, IDictionary <String, WeightedSpanTerm> terms)
{
if (query is BooleanQuery)
{
BooleanClause[] queryClauses = ((BooleanQuery)query).GetClauses();
for (int i = 0; i < queryClauses.Length; i++)
{
if (!queryClauses[i].IsProhibited)
{
Extract(queryClauses[i].Query, terms);
}
}
}
else if (query is PhraseQuery)
{
PhraseQuery phraseQuery = ((PhraseQuery)query);
Term[] phraseQueryTerms = phraseQuery.GetTerms();
SpanQuery[] clauses = new SpanQuery[phraseQueryTerms.Length];
for (int i = 0; i < phraseQueryTerms.Length; i++)
{
clauses[i] = new SpanTermQuery(phraseQueryTerms[i]);
}
int slop = phraseQuery.Slop;
int[] positions = phraseQuery.GetPositions();
// add largest position increment to slop
if (positions.Length > 0)
{
int lastPos = positions[0];
int largestInc = 0;
int sz = positions.Length;
for (int i = 1; i < sz; i++)
{
int pos = positions[i];
int inc = pos - lastPos;
if (inc > largestInc)
{
largestInc = inc;
}
lastPos = pos;
}
if (largestInc > 1)
{
slop += largestInc;
}
}
bool inorder = slop == 0;
SpanNearQuery sp = new SpanNearQuery(clauses, slop, inorder);
sp.Boost = query.Boost;
ExtractWeightedSpanTerms(terms, sp);
}
else if (query is TermQuery)
{
ExtractWeightedTerms(terms, query);
}
else if (query is SpanQuery)
{
ExtractWeightedSpanTerms(terms, (SpanQuery)query);
}
else if (query is FilteredQuery)
{
Extract(((FilteredQuery)query).Query, terms);
}
else if (query is DisjunctionMaxQuery)
{
foreach (var q in ((DisjunctionMaxQuery)query))
{
Extract(q, terms);
}
}
else if (query is MultiTermQuery && expandMultiTermQuery)
{
MultiTermQuery mtq = ((MultiTermQuery)query);
if (mtq.RewriteMethod != MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE)
{
mtq = (MultiTermQuery)mtq.Clone();
mtq.RewriteMethod = MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE;
query = mtq;
}
FakeReader fReader = new FakeReader();
MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE.Rewrite(fReader, mtq);
if (fReader.Field != null)
{
IndexReader ir = GetReaderForField(fReader.Field);
Extract(query.Rewrite(ir), terms);
}
}
else if (query is MultiPhraseQuery)
{
MultiPhraseQuery mpq = (MultiPhraseQuery)query;
IList <Term[]> termArrays = mpq.GetTermArrays();
int[] positions = mpq.GetPositions();
if (positions.Length > 0)
{
int maxPosition = positions[positions.Length - 1];
for (int i = 0; i < positions.Length - 1; ++i)
{
if (positions[i] > maxPosition)
{
maxPosition = positions[i];
}
}
var disjunctLists = new List <SpanQuery> [maxPosition + 1];
int distinctPositions = 0;
for (int i = 0; i < termArrays.Count; ++i)
{
Term[] termArray = termArrays[i];
List <SpanQuery> disjuncts = disjunctLists[positions[i]];
if (disjuncts == null)
{
disjuncts = (disjunctLists[positions[i]] = new List <SpanQuery>(termArray.Length));
++distinctPositions;
}
for (int j = 0; j < termArray.Length; ++j)
{
disjuncts.Add(new SpanTermQuery(termArray[j]));
}
}
int positionGaps = 0;
int position = 0;
SpanQuery[] clauses = new SpanQuery[distinctPositions];
for (int i = 0; i < disjunctLists.Length; ++i)
{
List <SpanQuery> disjuncts = disjunctLists[i];
if (disjuncts != null)
{
clauses[position++] = new SpanOrQuery(disjuncts.ToArray());
}
else
{
++positionGaps;
}
}
int slop = mpq.Slop;
bool inorder = (slop == 0);
SpanNearQuery sp = new SpanNearQuery(clauses, slop + positionGaps, inorder);
sp.Boost = query.Boost;
ExtractWeightedSpanTerms(terms, sp);
}
}
}
