public void WhenISpecifyAnEndTime(StartOrEnd startOrEnd) { switch (startOrEnd) { case StartOrEnd.Start: _sicknessEpisodeEventCreationContext.SpecifyStartTime(); break; case StartOrEnd.End: _sicknessEpisodeEventCreationContext.SpecifyEndTime(); break; } }
public void ThenItShouldReflectMyDesiredEndTime(StartOrEnd startOrEnd) { switch (startOrEnd) { case StartOrEnd.Start: _sicknessEpisodeEventCreationContext.AssertCorrectStartDateTime(); break; case StartOrEnd.End: _sicknessEpisodeEventCreationContext.AssertCorrectEndDateTime(); break; } }
private static bool StartsWithOrEndsWithIFast(this string str, string value, StartOrEnd startOrEnd) { if (str.IsEmpty() || str.Length < value.Length) { return(false); } // Note: ASCII chars are 0-127. Uppercase is 65-90; lowercase is 97-122. // Therefore, if a char is in one of these ranges, one can convert between cases by simply adding or // subtracting 32. bool start = startOrEnd == StartOrEnd.Start; int siStart = start ? 0 : str.Length - value.Length; int siEnd = start ? value.Length : str.Length; for (int si = siStart, vi = 0; si < siEnd; si++, vi++) { // If we find a non-ASCII character, give up and run the slow check on the whole string. We do // this because one .NET char doesn't necessarily equal one Unicode char. Multiple .NET chars // might be needed. So we grit our teeth and take the perf hit of letting .NET handle it. // This is tuned for ASCII being the more common case, so we can save an advance check for non- // ASCII chars, at the expense of being slightly (probably insignificantly) slower if there are // in fact non-ASCII chars in value. if (value[vi] > 127) { return(start ? str.StartsWith(value, OrdinalIgnoreCase) : str.EndsWith(value, OrdinalIgnoreCase)); } if (!str[si].EqualsIAscii(value[vi])) { return(false); } } return(true); }
private static bool StartsWithOrEndsWithFast(this string str, string value, CaseComparison caseComparison, StartOrEnd startOrEnd) { if (string.IsNullOrEmpty(str) || str.Length < value.Length) { return(false); } // Note: ASCII chars are 0-127. Uppercase is 65-90; lowercase is 97-122. // Therefore, if a char is in one of these ranges, one can convert between cases by simply adding or // subtracting 32. var start = startOrEnd == StartOrEnd.Start; var siStart = start ? 0 : str.Length - value.Length; var siEnd = start ? value.Length : str.Length; for (int si = siStart, vi = 0; si < siEnd; si++, vi++) { // If we find a non-ASCII character, give up and run the slow check on the whole string. We do // this because one .NET char doesn't necessarily equal one Unicode char. Multiple .NET chars // might be needed. So we grit our teeth and take the perf hit of letting .NET handle it. // This is tuned for ASCII being the more common case, so we can save an advance check for non- // ASCII chars, at the expense of being slightly (probably insignificantly) slower if there are // in fact non-ASCII chars in value. if (value[vi] > 127) { switch (caseComparison) { case CaseComparison.CaseSensitive: return(start ? str.StartsWith(value, Ordinal) : str.EndsWith(value, Ordinal)); case CaseComparison.CaseInsensitive: return(start ? str.StartsWith(value, OrdinalIgnoreCase) : str.EndsWith(value, OrdinalIgnoreCase)); case CaseComparison.GivenOrUpper: return(start ? str.StartsWith(value, Ordinal) || str.StartsWith(value.ToUpperInvariant(), Ordinal) : str.EndsWith(value, Ordinal) || str.EndsWith(value.ToUpperInvariant(), Ordinal)); case CaseComparison.GivenOrLower: return(start ? str.StartsWith(value, Ordinal) || str.StartsWith(value.ToLowerInvariant(), Ordinal) : str.EndsWith(value, Ordinal) || str.EndsWith(value.ToLowerInvariant(), Ordinal)); } } if (str[si] >= 65 && str[si] <= 90 && value[vi] >= 97 && value[vi] <= 122) { if (caseComparison == CaseComparison.GivenOrLower || str[si] != value[vi] - 32) { return(false); } } else if (value[vi] >= 65 && value[vi] <= 90 && str[si] >= 97 && str[si] <= 122) { if (caseComparison == CaseComparison.GivenOrUpper || str[si] != value[vi] + 32) { return(false); } } else if (str[si] != value[vi]) { return(false); } } return(true); }