public void Add_KV_ExistingKey()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc1", "Doc 1", "d", DateTime.Now), new SortedBasicWordInfoSet());
dic.Add(MockDocument("Doc1", "Doc 2", "d2", DateTime.Now.AddHours(1)), new SortedBasicWordInfoSet());
}
public void Add_KV_ExistingKey()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc1", "Doc 1", "d", DateTime.Now), new SortedBasicWordInfoSet());
Assert.That(() => dic.Add(MockDocument("Doc1", "Doc 2", "d2", DateTime.Now.AddHours(1)), new SortedBasicWordInfoSet()), Throws.ArgumentException);
}
public void Keys()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
IDocument doc1 = MockDocument("Doc1", "Doc1", "d", DateTime.Now);
IDocument doc2 = MockDocument("Doc2", "Doc2", "d", DateTime.Now);
dic.Add(doc1, new SortedBasicWordInfoSet());
dic.Add(doc2, new SortedBasicWordInfoSet());
Assert.AreEqual(2, dic.Keys.Count, "Wrong key count");
bool doc1Found = false, doc2Found = false;
foreach (IDocument d in dic.Keys)
{
if (d.Name == "Doc1")
{
doc1Found = true;
}
if (d.Name == "Doc2")
{
doc2Found = true;
}
}
Assert.IsTrue(doc1Found, "Doc1 not found");
Assert.IsTrue(doc2Found, "Doc2 not found");
}
public void Values()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
IDocument doc1 = MockDocument("Doc1", "Doc1", "d", DateTime.Now);
IDocument doc2 = MockDocument("Doc2", "Doc2", "d", DateTime.Now);
SortedBasicWordInfoSet set1 = new SortedBasicWordInfoSet();
set1.Add(new BasicWordInfo(0, 0, WordLocation.Content));
SortedBasicWordInfoSet set2 = new SortedBasicWordInfoSet();
set2.Add(new BasicWordInfo(1, 1, WordLocation.Title));
dic.Add(doc1, set1);
dic.Add(doc2, set2);
Assert.AreEqual(2, dic.Values.Count, "Wrong value count");
bool set1Found = false, set2Found = false;
foreach (SortedBasicWordInfoSet set in dic.Values)
{
if (set[0].FirstCharIndex == 0)
{
set1Found = true;
}
if (set[0].FirstCharIndex == 1)
{
set2Found = true;
}
}
Assert.IsTrue(set1Found, "Set1 not found");
Assert.IsTrue(set2Found, "Set2 not found");
}
public void RemoveExtended()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
SortedBasicWordInfoSet set1 = new SortedBasicWordInfoSet();
set1.Add(new BasicWordInfo(5, 0, WordLocation.Content));
set1.Add(new BasicWordInfo(12, 1, WordLocation.Keywords));
SortedBasicWordInfoSet set2 = new SortedBasicWordInfoSet();
set2.Add(new BasicWordInfo(1, 0, WordLocation.Content));
set2.Add(new BasicWordInfo(4, 1, WordLocation.Title));
dic.Add(MockDocument("Doc1", "Doc", "doc", DateTime.Now), set1);
dic.Add(MockDocument("Doc2", "Doc", "doc", DateTime.Now), set2);
List <DumpedWordMapping> dm = dic.RemoveExtended(MockDocument("Doc1", "Doc", "doc", DateTime.Now), 1);
Assert.AreEqual(2, dm.Count, "Wrong count");
Assert.IsTrue(dm.Find(delegate(DumpedWordMapping m) {
return(m.WordID == 1 && m.DocumentID == 1 &&
m.FirstCharIndex == 5 && m.WordIndex == 0 &&
m.Location == WordLocation.Content.Location);
}) != null, "Mapping not found");
Assert.IsTrue(dm.Find(delegate(DumpedWordMapping m) {
return(m.WordID == 1 && m.DocumentID == 1 &&
m.FirstCharIndex == 12 && m.WordIndex == 1 &&
m.Location == WordLocation.Keywords.Location);
}) != null, "Mapping not found");
}
public void Add_KV()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc1", "Doc 1", "d", DateTime.Now), new SortedBasicWordInfoSet());
Assert.AreEqual(1, dic.Count, "Wrong count");
dic.Add(MockDocument("Doc2", "Doc 2", "d", DateTime.Now), new SortedBasicWordInfoSet());
Assert.AreEqual(2, dic.Count, "Wrong count");
}
public void Add_KV()
{
OccurrenceDictionary sut = new OccurrenceDictionary();
sut.Add(MockDocument("Doc1", "Doc 1", "d", DateTime.Now), new SortedBasicWordInfoSet());
Assert.Single(sut);
sut.Add(MockDocument("Doc2", "Doc 2", "d", DateTime.Now), new SortedBasicWordInfoSet());
Assert.Equal(2, sut.Count);
}
public void Add_KV_ExistingKey()
{
OccurrenceDictionary sut = new OccurrenceDictionary();
sut.Add(MockDocument("Doc1", "Doc 1", "d", DateTime.Now), new SortedBasicWordInfoSet());
var ex = Assert.Throws <ArgumentException>(() => sut.Add(MockDocument("Doc1", "Doc 2", "d2", DateTime.Now.AddHours(1)), new SortedBasicWordInfoSet()));
Assert.Equal("The specified key is already contained in the dictionary.\r\nParameter name: key", ex.Message);
}
public void Add_KV()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc1", "Doc 1", "d", DateTime.Now), new SortedBasicWordInfoSet());
Assert.AreEqual(1, dic.Count, "Wrong count");
dic.Add(MockDocument("Doc2", "Doc 2", "d", DateTime.Now), new SortedBasicWordInfoSet());
Assert.AreEqual(2, dic.Count, "Wrong count");
}
public void Add_Pair()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(new KeyValuePair <IDocument, SortedBasicWordInfoSet>(
MockDocument("Doc1", "Doc 1", "d", DateTime.Now), new SortedBasicWordInfoSet()));
Assert.Single(dic);
dic.Add(MockDocument("Doc2", "Doc 2", "d", DateTime.Now), new SortedBasicWordInfoSet());
Assert.Equal(2, dic.Count);
}
public void Add_Pair()
{
var dic = new OccurrenceDictionary();
dic.Add(new KeyValuePair <IDocument, SortedBasicWordInfoSet>(
MockDocument("Doc1", "Doc 1", "d", DateTime.Now), new SortedBasicWordInfoSet()));
Assert.AreEqual(1, dic.Count, "Wrong count");
dic.Add(MockDocument("Doc2", "Doc 2", "d", DateTime.Now), new SortedBasicWordInfoSet());
Assert.AreEqual(2, dic.Count, "Wrong count");
}
public void Remove_Pair()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc1", "Doc1", "d", DateTime.Now), new SortedBasicWordInfoSet());
dic.Add(MockDocument("Doc2", "Doc2", "d", DateTime.Now), new SortedBasicWordInfoSet());
Assert.Equal(2, dic.Count);
Assert.False(dic.Remove(new KeyValuePair <IDocument, SortedBasicWordInfoSet>(MockDocument("Doc3", "Doc3", "d", DateTime.Now), new SortedBasicWordInfoSet())), "Remove should return false");
Assert.True(dic.Remove(new KeyValuePair <IDocument, SortedBasicWordInfoSet>(MockDocument("Doc2", "Doc2", "d", DateTime.Now), new SortedBasicWordInfoSet())), "Remove should return true");
Assert.Single(dic);
}
public void Remove_KV()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
SortedBasicWordInfoSet set = new SortedBasicWordInfoSet();
set.Add(new BasicWordInfo(5, 0, WordLocation.Content));
dic.Add(MockDocument("Doc1", "Doc1", "d", DateTime.Now), set);
dic.Add(MockDocument("Doc2", "Doc2", "d", DateTime.Now), new SortedBasicWordInfoSet());
Assert.AreEqual(2, dic.Count, "Wrong initial count");
Assert.IsFalse(dic.Remove(MockDocument("Doc3", "Doc3", "d", DateTime.Now)), "Remove should return false");
Assert.IsTrue(dic.Remove(MockDocument("Doc1", "Doc1", "d", DateTime.Now)), "Remove should return true");
Assert.AreEqual(1, dic.Count, "Wrong count");
}
public void Indexer_Set_NullValue()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc1", "Doc1", "d", DateTime.Now), new SortedBasicWordInfoSet());
Assert.That(() => { dic[MockDocument("Doc1", "Doc1", "d", DateTime.Now)] = null; }, Throws.ArgumentNullException);
}
public void Add_KV_Key_Null()
{
OccurrenceDictionary sut = new OccurrenceDictionary();
var ex = Assert.Throws <ArgumentNullException>(() => sut.Add(null, new SortedBasicWordInfoSet()));
Assert.Equal("Value cannot be null.\r\nParameter name: key", ex.Message);
}
public void Add_KV_Value_Null()
{
OccurrenceDictionary sut = new OccurrenceDictionary();
var ex = Assert.Throws <ArgumentNullException>(() => sut.Add(MockDocument("Doc1", "Doc 1", "d", DateTime.Now), null));
Assert.Equal("Value cannot be null.\r\nParameter name: value", ex.Message);
}
public void Indexer_Set_Value_Null()
{
OccurrenceDictionary sut = new OccurrenceDictionary();
sut.Add(MockDocument("Doc1", "Doc1", "d", DateTime.Now), new SortedBasicWordInfoSet());
var ex = Assert.Throws <ArgumentNullException>("value", () => sut[MockDocument("Doc1", "Doc1", "d", DateTime.Now)] = null);
}
public void Indexer_Set_NullValue()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc1", "Doc1", "d", DateTime.Now), new SortedBasicWordInfoSet());
dic[MockDocument("Doc1", "Doc1", "d", DateTime.Now)] = null;
}
public void CopyTo_InvalidIndex_Negative()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc", "Doc", "d", DateTime.Now), new SortedBasicWordInfoSet());
KeyValuePair <IDocument, SortedBasicWordInfoSet>[] array = new KeyValuePair <IDocument, SortedBasicWordInfoSet> [1];
Assert.Throws <IndexOutOfRangeException>(() => dic.CopyTo(array, -1));
}
public void CopyTo_InvalidIndex_TooBig()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc", "Doc", "d", DateTime.Now), new SortedBasicWordInfoSet());
KeyValuePair <IDocument, SortedBasicWordInfoSet>[] array = new KeyValuePair <IDocument, SortedBasicWordInfoSet> [1];
dic.CopyTo(array, 1);
}
public void CopyTo_ShortArray()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc", "Doc", "d", DateTime.Now), new SortedBasicWordInfoSet());
KeyValuePair <IDocument, SortedBasicWordInfoSet>[] array = new KeyValuePair <IDocument, SortedBasicWordInfoSet> [0];
dic.CopyTo(array, 0);
}
public void Clear()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc1", "Doc1", "d", DateTime.Now), new SortedBasicWordInfoSet());
dic.Clear();
Assert.Empty(dic);
}
public void Remove_Pair()
{
var dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc1", "Doc1", "d", DateTime.Now), new SortedBasicWordInfoSet());
dic.Add(MockDocument("Doc2", "Doc2", "d", DateTime.Now), new SortedBasicWordInfoSet());
Assert.AreEqual(2, dic.Count, "Wrong initial count");
Assert.IsFalse(dic.Remove(
new KeyValuePair <IDocument, SortedBasicWordInfoSet>(MockDocument("Doc3", "Doc3", "d", DateTime.Now),
new SortedBasicWordInfoSet())),
"Remove should return false");
Assert.IsTrue(dic.Remove(
new KeyValuePair <IDocument, SortedBasicWordInfoSet>(MockDocument("Doc2", "Doc2", "d", DateTime.Now),
new SortedBasicWordInfoSet())),
"Remove should return true");
Assert.AreEqual(1, dic.Count, "Wrong count");
}
public void CopyTo_Index_TooBig()
{
OccurrenceDictionary sut = new OccurrenceDictionary();
sut.Add(MockDocument("Doc", "Doc", "d", DateTime.Now), new SortedBasicWordInfoSet());
KeyValuePair <IDocument, SortedBasicWordInfoSet>[] array = new KeyValuePair <IDocument, SortedBasicWordInfoSet> [1];
var ex = Assert.Throws <IndexOutOfRangeException>(() => sut.CopyTo(array, 1));
Assert.Equal("Index was outside the bounds of the array.", ex.Message);
}
public void GetEnumerator()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
IDocument doc1 = MockDocument("Doc1", "Doc1", "d", DateTime.Now);
IDocument doc2 = MockDocument("Doc2", "Doc2", "d", DateTime.Now);
dic.Add(doc1, new SortedBasicWordInfoSet());
dic.Add(doc2, new SortedBasicWordInfoSet());
Assert.IsNotNull(dic.GetEnumerator(), "GetEnumerator should not return null");
int count = 0;
foreach (KeyValuePair <IDocument, SortedBasicWordInfoSet> pair in dic)
{
count++;
}
Assert.AreEqual(2, count, "Wrong count");
}
public void CopyTo()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
SortedBasicWordInfoSet set = new SortedBasicWordInfoSet();
set.Add(new BasicWordInfo(1, 1, WordLocation.Title));
dic.Add(MockDocument("Doc", "Doc", "d", DateTime.Now), set);
KeyValuePair <IDocument, SortedBasicWordInfoSet>[] array = new KeyValuePair <IDocument, SortedBasicWordInfoSet> [1];
dic.CopyTo(array, 0);
Assert.Equal("Doc", array[0].Key.Name);
Assert.Equal(1, array[0].Value.Count);
Assert.Equal(1, array[0].Value[0].FirstCharIndex);
}
public void ContainsKey()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
IDocument doc = MockDocument("Doc", "Doc", "d", DateTime.Now);
Assert.IsFalse(dic.ContainsKey(doc), "ContainsKey should return false");
dic.Add(doc, new SortedBasicWordInfoSet());
Assert.IsTrue(dic.ContainsKey(doc), "ContainsKey should return true");
Assert.IsFalse(dic.ContainsKey(MockDocument("Doc2", "Doc 2", "d", DateTime.Now)), "ContainsKey should return false");
IDocument doc2 = MockDocument("Doc", "Doc", "d", DateTime.Now);
Assert.IsTrue(dic.ContainsKey(doc2), "ContainsKey should return true");
}
public void Contains()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
IDocument doc = MockDocument("Doc", "Doc", "d", DateTime.Now);
Assert.False(dic.Contains(new KeyValuePair <IDocument, SortedBasicWordInfoSet>(doc, new SortedBasicWordInfoSet())), "Contains should return false");
dic.Add(doc, new SortedBasicWordInfoSet());
Assert.True(dic.Contains(new KeyValuePair <IDocument, SortedBasicWordInfoSet>(doc, new SortedBasicWordInfoSet())), "Contains should return true");
Assert.False(dic.Contains(new KeyValuePair <IDocument, SortedBasicWordInfoSet>(MockDocument("Doc2", "Doc 2", "d", DateTime.Now), new SortedBasicWordInfoSet())), "Contains should return false");
IDocument doc2 = MockDocument("Doc", "Doc", "d", DateTime.Now);
Assert.True(dic.Contains(new KeyValuePair <IDocument, SortedBasicWordInfoSet>(doc, new SortedBasicWordInfoSet())), "Contains should return true");
}
public void CopyTo()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
SortedBasicWordInfoSet set = new SortedBasicWordInfoSet();
set.Add(new BasicWordInfo(1, 1, WordLocation.Title));
dic.Add(MockDocument("Doc", "Doc", "d", DateTime.Now), set);
KeyValuePair <IDocument, SortedBasicWordInfoSet>[] array = new KeyValuePair <IDocument, SortedBasicWordInfoSet> [1];
dic.CopyTo(array, 0);
Assert.IsNotNull(array[0], "Array[0] should not be null");
Assert.AreEqual("Doc", array[0].Key.Name, "Wrong array item");
Assert.AreEqual(1, array[0].Value.Count, "Wrong count");
Assert.AreEqual(1, array[0].Value[0].FirstCharIndex, "Wrong first char index");
}
public void Indexer_Get()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
IDocument doc1 = MockDocument("Doc1", "Doc1", "d", DateTime.Now);
SortedBasicWordInfoSet set1 = new SortedBasicWordInfoSet();
set1.Add(new BasicWordInfo(1, 1, WordLocation.Content));
dic.Add(doc1, set1);
SortedBasicWordInfoSet output = dic[MockDocument("Doc1", "Doc1", "d", DateTime.Now)];
Assert.IsNotNull(output, "Output should not be null");
Assert.AreEqual(1, set1.Count, "Wrong count");
Assert.AreEqual(1, set1[0].FirstCharIndex, "Wrong first char index");
}
public void Indexer_Get()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
IDocument doc1 = MockDocument("Doc1", "Doc1", "d", DateTime.Now);
SortedBasicWordInfoSet set1 = new SortedBasicWordInfoSet();
set1.Add(new BasicWordInfo(1, 1, WordLocation.Content));
dic.Add(doc1, set1);
SortedBasicWordInfoSet output = dic[MockDocument("Doc1", "Doc1", "d", DateTime.Now)];
Assert.NotNull(output);
Assert.Equal(1, set1.Count);
Assert.Equal(1, set1[0].FirstCharIndex);
}
public void Indexer_Set_NullValue()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc1", "Doc1", "d", DateTime.Now), new SortedBasicWordInfoSet());
dic[MockDocument("Doc1", "Doc1", "d", DateTime.Now)] = null;
}
public void Keys()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
IDocument doc1 = MockDocument("Doc1", "Doc1", "d", DateTime.Now);
IDocument doc2 = MockDocument("Doc2", "Doc2", "d", DateTime.Now);
dic.Add(doc1, new SortedBasicWordInfoSet());
dic.Add(doc2, new SortedBasicWordInfoSet());
Assert.AreEqual(2, dic.Keys.Count, "Wrong key count");
bool doc1Found = false, doc2Found = false;
foreach(IDocument d in dic.Keys) {
if(d.Name == "Doc1") doc1Found = true;
if(d.Name == "Doc2") doc2Found = true;
}
Assert.IsTrue(doc1Found, "Doc1 not found");
Assert.IsTrue(doc2Found, "Doc2 not found");
}
public void CopyTo_InvalidIndex_TooBig()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc", "Doc", "d", DateTime.Now), new SortedBasicWordInfoSet());
KeyValuePair<IDocument, SortedBasicWordInfoSet>[] array = new KeyValuePair<IDocument, SortedBasicWordInfoSet>[1];
dic.CopyTo(array, 1);
}
public void GetEnumerator()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
IDocument doc1 = MockDocument("Doc1", "Doc1", "d", DateTime.Now);
IDocument doc2 = MockDocument("Doc2", "Doc2", "d", DateTime.Now);
dic.Add(doc1, new SortedBasicWordInfoSet());
dic.Add(doc2, new SortedBasicWordInfoSet());
Assert.IsNotNull(dic.GetEnumerator(), "GetEnumerator should not return null");
int count = 0;
foreach(KeyValuePair<IDocument, SortedBasicWordInfoSet> pair in dic) {
count++;
}
Assert.AreEqual(2, count, "Wrong count");
}
public void TryGetValue()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
IDocument doc1 = MockDocument("Doc1", "Doc1", "d", DateTime.Now);
IDocument doc2 = MockDocument("Doc2", "Doc2", "d", DateTime.Now);
SortedBasicWordInfoSet set = null;
Assert.IsFalse(dic.TryGetValue(doc1, out set), "TryGetValue should return false");
Assert.IsNull(set, "Set should be null");
dic.Add(doc1, new SortedBasicWordInfoSet());
Assert.IsTrue(dic.TryGetValue(MockDocument("Doc1", "Doc1", "d", DateTime.Now), out set), "TryGetValue should return true");
Assert.IsNotNull(set, "Set should not be null");
Assert.IsFalse(dic.TryGetValue(doc2, out set), "TryGetValue should return false");
Assert.IsNull(set, "Set should have been set to null");
}
public void Values()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
IDocument doc1 = MockDocument("Doc1", "Doc1", "d", DateTime.Now);
IDocument doc2 = MockDocument("Doc2", "Doc2", "d", DateTime.Now);
SortedBasicWordInfoSet set1 = new SortedBasicWordInfoSet();
set1.Add(new BasicWordInfo(0, 0, WordLocation.Content));
SortedBasicWordInfoSet set2 = new SortedBasicWordInfoSet();
set2.Add(new BasicWordInfo(1, 1, WordLocation.Title));
dic.Add(doc1, set1);
dic.Add(doc2, set2);
Assert.AreEqual(2, dic.Values.Count, "Wrong value count");
bool set1Found = false, set2Found = false;
foreach(SortedBasicWordInfoSet set in dic.Values) {
if(set[0].FirstCharIndex == 0) set1Found = true;
if(set[0].FirstCharIndex == 1) set2Found = true;
}
Assert.IsTrue(set1Found, "Set1 not found");
Assert.IsTrue(set2Found, "Set2 not found");
}
public void Add_KV_NullValue()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc1", "Doc 1", "d", DateTime.Now), null);
}
public void Contains()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
IDocument doc = MockDocument("Doc", "Doc", "d", DateTime.Now);
Assert.IsFalse(dic.Contains(new KeyValuePair<IDocument, SortedBasicWordInfoSet>(doc, new SortedBasicWordInfoSet())), "Contains should return false");
dic.Add(doc, new SortedBasicWordInfoSet());
Assert.IsTrue(dic.Contains(new KeyValuePair<IDocument, SortedBasicWordInfoSet>(doc, new SortedBasicWordInfoSet())), "Contains should return true");
Assert.IsFalse(dic.Contains(new KeyValuePair<IDocument, SortedBasicWordInfoSet>(MockDocument("Doc2", "Doc 2", "d", DateTime.Now), new SortedBasicWordInfoSet())), "Contains should return false");
IDocument doc2 = MockDocument("Doc", "Doc", "d", DateTime.Now);
Assert.IsTrue(dic.Contains(new KeyValuePair<IDocument, SortedBasicWordInfoSet>(doc, new SortedBasicWordInfoSet())), "Contains should return true");
}
/// <summary>
/// Tries to load all data related to a word from the database.
/// </summary>
/// <param name="text">The word text.</param>
/// <param name="word">The returned word.</param>
/// <param name="connection">An open database connection.</param>
/// <returns><c>true</c> if the word is found, <c>false</c> otherwise.</returns>
private bool TryFindWord(string text, out Word word, DbConnection connection)
{
// 1. Find word - if not found, return
// 2. Read all raw word mappings
// 3. Read all documents (unique)
// 4. Build result data structure
ICommandBuilder builder = GetCommandBuilder();
QueryBuilder queryBuilder = new QueryBuilder(builder);
string query = queryBuilder.SelectFrom("IndexWord", new string[] { "Id" });
query = queryBuilder.Where(query, "Text", WhereOperator.Equals, "Text");
List<Parameter> parameters = new List<Parameter>(1);
parameters.Add(new Parameter(ParameterType.String, "Text", text));
DbCommand command = builder.GetCommand(connection, query, parameters);
int wordId = ExecuteScalar<int>(command, -1, false);
if(wordId == -1) {
word = null;
return false;
}
// Read all raw mappings
query = queryBuilder.SelectFrom("IndexWordMapping");
query = queryBuilder.Where(query, "Word", WhereOperator.Equals, "WordId");
parameters = new List<Parameter>(1);
parameters.Add(new Parameter(ParameterType.Int32, "WordId", wordId));
command = builder.GetCommand(connection, query, parameters);
DbDataReader reader = ExecuteReader(command, false);
List<DumpedWordMapping> mappings = new List<DumpedWordMapping>(2048);
while(reader != null && reader.Read()) {
mappings.Add(new DumpedWordMapping((uint)wordId,
(uint)(int)reader["Document"],
(ushort)(short)reader["FirstCharIndex"], (ushort)(short)reader["WordIndex"],
(byte)reader["Location"]));
}
CloseReader(reader);
if(mappings.Count == 0) {
word = null;
return false;
}
// Find all documents
query = queryBuilder.SelectFrom("IndexDocument");
query = queryBuilder.Where(query, "Id", WhereOperator.Equals, "DocId");
parameters = new List<Parameter>(1);
parameters.Add(new Parameter(ParameterType.Int32, "DocId", 0));
Dictionary<uint, IDocument> documents = new Dictionary<uint, IDocument>(64);
foreach(DumpedWordMapping map in mappings) {
uint docId = map.DocumentID;
if(documents.ContainsKey(docId)) continue;
parameters[0].Value = (int)docId;
command = builder.GetCommand(connection, query, parameters);
reader = ExecuteReader(command, false);
if(reader != null && reader.Read()) {
DumpedDocument dumpedDoc = new DumpedDocument(docId,
reader["Name"] as string, reader["Title"] as string,
reader["TypeTag"] as string,
(DateTime)reader["DateTime"]);
IDocument document = BuildDocument(dumpedDoc);
if(document != null) documents.Add(docId, document);
}
CloseReader(reader);
}
OccurrenceDictionary occurrences = new OccurrenceDictionary(mappings.Count);
foreach(DumpedWordMapping map in mappings) {
if(!occurrences.ContainsKey(documents[map.DocumentID])) {
occurrences.Add(documents[map.DocumentID], new SortedBasicWordInfoSet(2));
}
occurrences[documents[map.DocumentID]].Add(new BasicWordInfo(
map.FirstCharIndex, map.WordIndex, WordLocation.GetInstance(map.Location)));
}
word = new Word((uint)wordId, text, occurrences);
return true;
}
public void Add_KV_ExistingKey()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc1", "Doc 1", "d", DateTime.Now), new SortedBasicWordInfoSet());
dic.Add(MockDocument("Doc1", "Doc 2", "d2", DateTime.Now.AddHours(1)), new SortedBasicWordInfoSet());
}
public void Remove_Pair()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc1", "Doc1", "d", DateTime.Now), new SortedBasicWordInfoSet());
dic.Add(MockDocument("Doc2", "Doc2", "d", DateTime.Now), new SortedBasicWordInfoSet());
Assert.AreEqual(2, dic.Count, "Wrong initial count");
Assert.IsFalse(dic.Remove(
new KeyValuePair<IDocument, SortedBasicWordInfoSet>(MockDocument("Doc3", "Doc3", "d", DateTime.Now), new SortedBasicWordInfoSet())),
"Remove should return false");
Assert.IsTrue(dic.Remove(
new KeyValuePair<IDocument, SortedBasicWordInfoSet>(MockDocument("Doc2", "Doc2", "d", DateTime.Now), new SortedBasicWordInfoSet())),
"Remove should return true");
Assert.AreEqual(1, dic.Count, "Wrong count");
}
public void Indexer_Set()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc1", "Doc1", "d", DateTime.Now), new SortedBasicWordInfoSet());
SortedBasicWordInfoSet set1 = new SortedBasicWordInfoSet();
set1.Add(new BasicWordInfo(1, 1, WordLocation.Content));
dic[MockDocument("Doc1", "Doc1", "d", DateTime.Now)] = set1;
SortedBasicWordInfoSet output = dic[MockDocument("Doc1", "Doc1", "d", DateTime.Now)];
Assert.AreEqual(1, output.Count, "Wrong count");
Assert.AreEqual(1, output[0].FirstCharIndex, "Wrong first char index");
}
public void Add_KV_NullKey()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(null, new SortedBasicWordInfoSet());
}
public void Indexer_Get()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
IDocument doc1 = MockDocument("Doc1", "Doc1", "d", DateTime.Now);
SortedBasicWordInfoSet set1 = new SortedBasicWordInfoSet();
set1.Add(new BasicWordInfo(1, 1, WordLocation.Content));
dic.Add(doc1, set1);
SortedBasicWordInfoSet output = dic[MockDocument("Doc1", "Doc1", "d", DateTime.Now)];
Assert.IsNotNull(output, "Output should not be null");
Assert.AreEqual(1, set1.Count, "Wrong count");
Assert.AreEqual(1, set1[0].FirstCharIndex, "Wrong first char index");
}
public void Remove_KV()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
SortedBasicWordInfoSet set = new SortedBasicWordInfoSet();
set.Add(new BasicWordInfo(5, 0, WordLocation.Content));
dic.Add(MockDocument("Doc1", "Doc1", "d", DateTime.Now), set);
dic.Add(MockDocument("Doc2", "Doc2", "d", DateTime.Now), new SortedBasicWordInfoSet());
Assert.AreEqual(2, dic.Count, "Wrong initial count");
Assert.IsFalse(dic.Remove(MockDocument("Doc3", "Doc3", "d", DateTime.Now)), "Remove should return false");
Assert.IsTrue(dic.Remove(MockDocument("Doc1", "Doc1", "d", DateTime.Now)), "Remove should return true");
Assert.AreEqual(1, dic.Count, "Wrong count");
}
public void CopyTo_ShortArray()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
dic.Add(MockDocument("Doc", "Doc", "d", DateTime.Now), new SortedBasicWordInfoSet());
KeyValuePair<IDocument, SortedBasicWordInfoSet>[] array = new KeyValuePair<IDocument,SortedBasicWordInfoSet>[0];
dic.CopyTo(array, 0);
}
public void RemoveExtended()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
SortedBasicWordInfoSet set1 = new SortedBasicWordInfoSet();
set1.Add(new BasicWordInfo(5, 0, WordLocation.Content));
set1.Add(new BasicWordInfo(12, 1, WordLocation.Keywords));
SortedBasicWordInfoSet set2 = new SortedBasicWordInfoSet();
set2.Add(new BasicWordInfo(1, 0, WordLocation.Content));
set2.Add(new BasicWordInfo(4, 1, WordLocation.Title));
dic.Add(MockDocument("Doc1", "Doc", "doc", DateTime.Now), set1);
dic.Add(MockDocument("Doc2", "Doc", "doc", DateTime.Now), set2);
List<DumpedWordMapping> dm = dic.RemoveExtended(MockDocument("Doc1", "Doc", "doc", DateTime.Now), 1);
Assert.AreEqual(2, dm.Count, "Wrong count");
Assert.IsTrue(dm.Find(delegate(DumpedWordMapping m) {
return m.WordID == 1 && m.DocumentID == 1 &&
m.FirstCharIndex == 5 && m.WordIndex == 0 &&
m.Location == WordLocation.Content.Location;
}) != null, "Mapping not found");
Assert.IsTrue(dm.Find(delegate(DumpedWordMapping m) {
return m.WordID == 1 && m.DocumentID == 1 &&
m.FirstCharIndex == 12 && m.WordIndex == 1 &&
m.Location == WordLocation.Keywords.Location;
}) != null, "Mapping not found");
}
public void Constructor_3Params_1Occurrence()
{
OccurrenceDictionary occ = new OccurrenceDictionary();
IDocument doc = MockDocument("Doc", "Doc", "d", DateTime.Now);
SortedBasicWordInfoSet set = new SortedBasicWordInfoSet();
set.Add(new BasicWordInfo(0, 0, WordLocation.Content));
occ.Add(doc, set);
Word word = new Word(12, "Hello", occ);
Assert.AreEqual("hello", word.Text, "Wrong word text");
Assert.AreEqual(1, word.Occurrences.Count, "Wrong occurrences count");
Assert.AreEqual(1, word.TotalOccurrences, "Wrong total occurrences count");
}
public void CopyTo()
{
OccurrenceDictionary dic = new OccurrenceDictionary();
SortedBasicWordInfoSet set = new SortedBasicWordInfoSet();
set.Add(new BasicWordInfo(1, 1, WordLocation.Title));
dic.Add(MockDocument("Doc", "Doc", "d", DateTime.Now), set);
KeyValuePair<IDocument, SortedBasicWordInfoSet>[] array = new KeyValuePair<IDocument, SortedBasicWordInfoSet>[1];
dic.CopyTo(array, 0);
Assert.IsNotNull(array[0], "Array[0] should not be null");
Assert.AreEqual("Doc", array[0].Key.Name, "Wrong array item");
Assert.AreEqual(1, array[0].Value.Count, "Wrong count");
Assert.AreEqual(1, array[0].Value[0].FirstCharIndex, "Wrong first char index");
}