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)); }
/// ------------------------------------------------------------------------------------ /// <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 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); }