public void ValidScrReferences()
{
ScrReference bcvRef = new ScrReference(1, 2, 3, ScrVers.English);
Assert.IsTrue(bcvRef.Valid);
Assert.IsFalse(bcvRef.IsBookTitle);
Assert.AreEqual(1002003, (int)bcvRef);
Assert.AreEqual(1, bcvRef.Book);
Assert.AreEqual(2, bcvRef.Chapter);
Assert.AreEqual(3, bcvRef.Verse);
Assert.AreEqual(ScrVers.English, bcvRef.Versification);
bcvRef = new ScrReference(4005006, ScrVers.Original);
Assert.IsTrue(bcvRef.Valid);
Assert.IsFalse(bcvRef.IsBookTitle);
Assert.AreEqual(4005006, (int)bcvRef);
Assert.AreEqual(4, bcvRef.Book);
Assert.AreEqual(5, bcvRef.Chapter);
Assert.AreEqual(6, bcvRef.Verse);
Assert.AreEqual(ScrVers.Original, bcvRef.Versification);
bcvRef = new ScrReference();
Assert.IsFalse(bcvRef.Valid);
Assert.IsFalse(bcvRef.IsBookTitle);
Assert.AreEqual(0, (int)bcvRef);
Assert.AreEqual(0, bcvRef.Book);
Assert.AreEqual(0, bcvRef.Chapter);
Assert.AreEqual(0, bcvRef.Verse);
bcvRef = new ScrReference(5, 0, 0, ScrVers.English);
Assert.IsFalse(bcvRef.Valid);
Assert.IsTrue(bcvRef.IsBookTitle);
Assert.AreEqual(5000000, (int)bcvRef);
Assert.AreEqual(5, bcvRef.Book);
Assert.AreEqual(0, bcvRef.Chapter);
Assert.AreEqual(0, bcvRef.Verse);
}
public void CompareTo_BCVRef()
{
ScrReference ref1 = new ScrReference("GEN 30:1", ScrVers.Original);
BCVRef ref2 = new BCVRef("GEN 30:1");
Assert.AreEqual(0, ref1.CompareTo(ref2));
}
public void LessThan_int()
{
ScrReference ref2 = new ScrReference("GEN 30:2", ScrVers.Original);
Assert.IsTrue(1030001 < ref2);
}
public void LessThan_UnknownVersification()
{
ScrReference ref1 = new ScrReference("GEN 30:1", ScrVers.Unknown);
ScrReference ref2 = new ScrReference("GEN 30:1", ScrVers.Original);
Assert.IsFalse(ref1 < ref2);
ref1 = new ScrReference("GEN 19:1", ScrVers.Unknown);
ref2 = new ScrReference("GEN 21:1", ScrVers.English);
Assert.IsTrue(ref1 < ref2);
ref1 = new ScrReference("GEN 21:1", ScrVers.Unknown);
ref2 = new ScrReference("GEN 19:1", ScrVers.English);
Assert.IsFalse(ref1 < ref2);
}
public void Equal_DifferentVersification()
{
ScrReference ref1 = new ScrReference("GEN 31:55", ScrVers.English);
ScrReference ref2 = new ScrReference("GEN 32:1", ScrVers.Original);
Assert.IsTrue(ref1 == ref2);
ref1 = new ScrReference("JOB 41:9", ScrVers.English);
ref2 = new ScrReference("JOB 41:1", ScrVers.Original);
Assert.IsTrue(ref1 == ref2);
ref1 = new ScrReference("JOB 41:9", ScrVers.English);
ref2 = new ScrReference("JOB 41:2", ScrVers.Original);
Assert.IsFalse(ref1 == ref2);
}
public void ParseRefString_InvalidVersification()
{
ScrReference reference = new ScrReference("GEN 1:1", ScrVers.Unknown);
Assert.IsFalse(reference.Valid);
}
public void GetLastChapterForBook()
{
ScrReference scrRef = new ScrReference("HAG 1:1", ScrVers.English);
Assert.AreEqual(2, scrRef.LastChapter);
scrRef.Book = ScrReference.BookToNumber("PSA");
Assert.AreEqual(150, scrRef.LastChapter);
scrRef.Book = 456;
Assert.AreEqual(0, scrRef.LastChapter);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the total number of chapters from the specified start ref to the end reference.
/// </summary>
/// <remarks>Note: This is based on the total number of chapters for the current
/// versification. If there are some chapters missing in a book present those will
/// not be accounted for.</remarks>
/// <param name="booksPresent">a bool array indicating the presence of each book.</param>
/// <param name="refStart">Scripture reference where importing begins.</param>
/// <param name="refEnd">Scripture reference where importing ends.</param>
/// <returns>The total number of chapters between the start and end references
/// (inclusively) in books that are present.
/// </returns>
/// ------------------------------------------------------------------------------------
public static int GetNumberOfChaptersInRange(List<int> booksPresent, ScrReference refStart,
ScrReference refEnd)
{
Debug.Assert(refStart.Versification == refEnd.Versification);
// Determine which chapter number to use in the start reference
int startChapter = (refStart.Chapter == 0) ? 1 : refStart.Chapter;
// Consider the case where the start and end references are in the same book.
if (refStart.Book == refEnd.Book)
return booksPresent.Contains(refStart.Book) ? refEnd.Chapter - startChapter + 1 : 0;
// Add up the number of chapters for the books from the start to the end.
int expectedChapters = 0;
for (int book = refStart.Book; book <= refEnd.Book; book++)
{
if (booksPresent.Contains(book))
{
ScrReference scRef = new ScrReference(book, 1, 1, refStart.Versification);
if (book == refStart.Book)
expectedChapters += refStart.LastChapter - startChapter + 1;
else if (book == refEnd.Book)
expectedChapters += refEnd.Chapter;
else
expectedChapters += scRef.LastChapter;
}
}
return expectedChapters;
}
public void VerseToIntTest()
{
int nVerseStart, nVerseEnd;
// Test invalid verse number strings
ScrReference.VerseToInt("-12", out nVerseStart, out nVerseEnd);
Assert.AreEqual(12, nVerseStart);
Assert.AreEqual(12, nVerseEnd);
ScrReference.VerseToInt("14-", out nVerseStart, out nVerseEnd);
Assert.AreEqual(14, nVerseStart);
Assert.AreEqual(14, nVerseEnd);
ScrReference.VerseToInt("a3", out nVerseStart, out nVerseEnd);
Assert.AreEqual(3, nVerseStart);
Assert.AreEqual(3, nVerseEnd);
ScrReference.VerseToInt("15b-a", out nVerseStart, out nVerseEnd);
Assert.AreEqual(15, nVerseStart);
Assert.AreEqual(15, nVerseEnd);
ScrReference.VerseToInt("3bb", out nVerseStart, out nVerseEnd);
Assert.AreEqual(3, nVerseStart);
Assert.AreEqual(3, nVerseEnd);
ScrReference.VerseToInt("0", out nVerseStart, out nVerseEnd);
Assert.AreEqual(0, nVerseStart);
Assert.AreEqual(0, nVerseEnd);
ScrReference.VerseToInt(" 12", out nVerseStart, out nVerseEnd);
Assert.AreEqual(12, nVerseStart);
Assert.AreEqual(12, nVerseEnd);
ScrReference.VerseToInt("14 ", out nVerseStart, out nVerseEnd);
Assert.AreEqual(14, nVerseStart);
Assert.AreEqual(14, nVerseEnd);
ScrReference.VerseToInt("12-10", out nVerseStart, out nVerseEnd);
Assert.AreEqual(12, nVerseStart);
//Assert.AreEqual(12, nVerseEnd); // end verse set to 12 instead of 10
ScrReference.VerseToInt("139-1140", out nVerseStart, out nVerseEnd);
Assert.AreEqual(139, nVerseStart);
//Assert.AreEqual(139, nVerseEnd); // end verse set to 999 instead of 139
ScrReference.VerseToInt("177-140", out nVerseStart, out nVerseEnd);
//Assert.AreEqual(140, nVerseStart); // start verse set to 177 instead of 140
Assert.AreEqual(140, nVerseEnd);
//Review: should this be a requirement?
// ScrReference.VerseToInt("177", out nVerseStart, out nVerseEnd);
// Assert.AreEqual(0, nVerseStart); // 177 is out of range of valid verse numbers
// Assert.AreEqual(0, nVerseEnd);
ScrReference.VerseToInt(String.Empty, out nVerseStart, out nVerseEnd);
Assert.AreEqual(0, nVerseStart);
Assert.AreEqual(0, nVerseEnd);
ScrReference.VerseToInt(String.Empty, out nVerseStart, out nVerseEnd);
Assert.AreEqual(0, nVerseStart);
Assert.AreEqual(0, nVerseEnd);
// Test valid verse number strings
ScrReference.VerseToInt("1a", out nVerseStart, out nVerseEnd);
Assert.AreEqual(1, nVerseStart);
Assert.AreEqual(1, nVerseEnd);
ScrReference.VerseToInt("2a-3b", out nVerseStart, out nVerseEnd);
Assert.AreEqual(2, nVerseStart);
Assert.AreEqual(3, nVerseEnd);
ScrReference.VerseToInt("4-5d", out nVerseStart, out nVerseEnd);
Assert.AreEqual(4, nVerseStart);
Assert.AreEqual(5, nVerseEnd);
ScrReference.VerseToInt("6", out nVerseStart, out nVerseEnd);
Assert.AreEqual(6, nVerseStart);
Assert.AreEqual(6, nVerseEnd);
ScrReference.VerseToInt("66", out nVerseStart, out nVerseEnd);
Assert.AreEqual(66, nVerseStart);
Assert.AreEqual(66, nVerseEnd);
ScrReference.VerseToInt("176", out nVerseStart, out nVerseEnd);
Assert.AreEqual(176, nVerseStart);
Assert.AreEqual(176, nVerseEnd);
//We expect this test to pass
//RTL verse bridge should be valid syntax
ScrReference.VerseToInt("6" + '\u200f' + "-" + '\u200f' + "8", out nVerseStart,
out nVerseEnd);
Assert.AreEqual(6, nVerseStart);
Assert.AreEqual(8, nVerseEnd);
}
public void CompareTo_int()
{
ScrReference ref1 = new ScrReference("GEN 30:1", ScrVers.Original);
Assert.AreEqual(0, ref1.CompareTo(1030001));
}
public void LessThan_int()
{
ScrReference ref2 = new ScrReference("GEN 30:2", ScrVers.Original);
Assert.IsTrue(1030001 < ref2);
}
public void ParseRefString_InvalidVersification()
{
ScrReference reference = new ScrReference("GEN 1:1", ScrVers.Unknown);
Assert.IsFalse(reference.Valid);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Compares the current instance with another object of the same type.
/// </summary>
/// <param name="obj">An object to compare with this instance.</param>
/// <returns>
/// A 32-bit signed integer that indicates the relative order of the objects being
/// compared. The return value has these meanings:
///
/// Value Meaning
/// Less than zero This instance is less than <paramref name="obj"/>.
/// Zero This instance is equal to <paramref name="obj"/>.
/// Greater than zero This instance is greater than <paramref name="obj"/>.
/// </returns>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="obj"/> is not the same type as this instance. </exception>
/// ------------------------------------------------------------------------------------
public override int CompareTo(object obj)
{
if (obj == null)
throw new ArgumentException();
ScrReference right;
if (obj is ScrReference)
{
right = (ScrReference)obj;
// If versifications don't match, make a new one, converted to correct versification
if (m_versification != right.m_versification &&
m_versification != ScrVers.Unknown &&
right.m_versification != ScrVers.Unknown)
{
// Neither of the versifications involved are unknown, so do a normal conversion
right = new ScrReference(right, m_versification);
}
else if (m_versification != right.m_versification)
{
// one of the versifications involved is unknown, so just treat it as the same
// versification as the known one.
if (right.m_versification != ScrVers.Unknown)
{
ScrReference newThis = new ScrReference(BBCCCVVV, right.m_versification);
return newThis.CompareTo(right);
}
right = new ScrReference(right.BBCCCVVV, m_versification);
}
}
else if (obj is BCVRef)
right = new ScrReference((BCVRef)obj, m_versification);
else if (obj is int)
right = new ScrReference((int)obj, m_versification);
else
throw new ArgumentException();
return base.CompareTo(right);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Copy a reference
/// </summary>
/// <param name="from">The ScrReference to copy.</param>
/// ------------------------------------------------------------------------------------
public ScrReference(ScrReference from)
: this(from.Book, from.Chapter, from.Verse, from.Segment, from.m_versification)
{
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Parses the given string representing the reference range.
/// </summary>
/// <param name="sRefRng">The string representing the reference range.</param>
/// <param name="bcvRefStart">The start reference (passed by ref because we use it to
/// infer any components of the reference that are misisng in sRefRng).</param>
/// <param name="bcvRefEnd">The end reference.</param>
/// <param name="versification">The versification.</param>
/// <returns>
/// <c>true</c> if successfully parsed; <c>false</c> otherwise
/// </returns>
/// ------------------------------------------------------------------------------------
public static bool ParseRefRange(string sRefRng, ref BCVRef bcvRefStart,
ref BCVRef bcvRefEnd, ScrVers versification)
{
if (string.IsNullOrEmpty(sRefRng))
return false;
if (!sRefRng.Contains("--"))
return BCVRef.ParseRefRange(sRefRng, ref bcvRefStart, ref bcvRefEnd, false);
sRefRng = sRefRng.Trim();
string[] pieces = sRefRng.Split(new string[] { "--" }, StringSplitOptions.RemoveEmptyEntries);
if (pieces.Length != 2)
return false;
string sFirstRef = pieces[0];
int bbcccvvvStart = bcvRefStart.BBCCCVVV;
bcvRefStart.Parse(sFirstRef);
if (!bcvRefStart.Valid)
{
bcvRefStart.BBCCCVVV = bbcccvvvStart;
return false;
}
string sEndRef = pieces[1];
int chapter;
if (Int32.TryParse(sEndRef, out chapter))
{
ScrReference scrRefEnd = new ScrReference(bcvRefStart.Book, chapter, 1, versification);
scrRefEnd.Verse = scrRefEnd.LastVerse;
bcvRefEnd.BBCCCVVV = scrRefEnd.BBCCCVVV;
return true;
}
return false;
}
public void CompareTo_int()
{
ScrReference ref1 = new ScrReference("GEN 30:1", ScrVers.Original);
Assert.AreEqual(0, ref1.CompareTo(1030001));
}
public void InvalidScrReferences()
{
// Invalid BCVs
ScrReference scrRef = new ScrReference(7, 8, 1001, ScrVers.English);
Assert.IsFalse(scrRef.Valid);
scrRef.MakeValid();
Assert.AreEqual(7008035, (int)scrRef);
Assert.AreEqual(7, scrRef.Book);
Assert.AreEqual(8, scrRef.Chapter);
Assert.AreEqual(35, scrRef.Verse);
scrRef = new ScrReference(9, 1002, 10, ScrVers.English);
Assert.IsFalse(scrRef.Valid);
scrRef.MakeValid();
Assert.AreEqual(9031010, (int)scrRef);
Assert.AreEqual(9, scrRef.Book);
Assert.AreEqual(31, scrRef.Chapter);
Assert.AreEqual(10, scrRef.Verse);
scrRef = new ScrReference(101, 11, 12, ScrVers.English);
Assert.IsFalse(scrRef.Valid);
scrRef.MakeValid();
Assert.AreEqual(66011012, (int)scrRef);
Assert.AreEqual(66, scrRef.Book);
Assert.AreEqual(11, scrRef.Chapter);
Assert.AreEqual(12, scrRef.Verse);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Copy a reference, converting it to the specified versification if necessary
/// </summary>
/// ------------------------------------------------------------------------------------
public ScrReference(ScrReference from, ScrVers targetVersification)
: this(from.Book, from.Chapter, from.Verse, from.Segment, from.m_versification)
{
VersificationTable.Get(targetVersification).ChangeVersification(this);
}
