Assert

src\coreclr\nativeaot\Runtime.Base\src\System\Runtime\ExceptionHandling.cs (13)

203Debug.Assert(false, "Unhandled exceptions should be processed by the native runtime only"); 655Debug.Assert(isValid, "Unwind and intercept failed unexpectedly"); 699Debug.Assert(false, "unreachable"); 727Debug.Assert(exInfo._passNumber == 1, "expected asm throw routine to set the pass"); 751Debug.Assert(isValid, "RhThrowEx called with an unexpected context"); 838Debug.Assert(pCatchHandler != null || pReversePInvokePropagationCallback != IntPtr.Zero || unwoundReversePInvoke || isExceptionIntercepted, "We should have a handler if we're starting the second pass"); 839Debug.Assert(!isExceptionIntercepted || (pCatchHandler == null), "No catch handler should be returned for intercepted exceptions in the first pass"); 863Debug.Assert(isValid, "second-pass EH unwind failed unexpectedly"); 878Debug.Assert(frameIter.SP == handlingFrameSP, "Encountered a different reverse P/Invoke frame in the second pass."); 931Debug.Assert(false, "unreachable"); 938Debug.Assert(ip != null, "IP address must not be null"); 944Debug.Assert(handlingFrameSP != MaxSP, "Handling frame must have an SP value"); 945Debug.Assert(((UIntPtr*)handlingFrameSP) > &handlingFrameSP,

src\libraries\Common\src\Interop\Linux\procfs\Interop.ProcFsStat.TryReadStatusFile.cs (1)

39Debug.Assert(!b || result.Pid == pid, "Expected process ID from status file to match supplied pid");

src\libraries\Common\src\Interop\Unix\Interop.IOErrors.cs (1)

14Debug.Assert(errorInfo.Error != Error.EINTR, "EINTR errors should be handled by the native shim and never bubble up to managed code");

src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadDir.cs (3)

40Debug.Assert(Name != null, "should not have a null name"); 47Debug.Assert(nameBytes.Length > 0, "we shouldn't have gotten a garbage value from the OS"); 51Debug.Assert(NameLength != -1 || !value.Contains('\0'), "should not have embedded nulls if we parsed the end of string");

src\libraries\Common\src\System\Collections\Concurrent\SingleProducerSingleConsumerQueue.cs (13)

67Debug.Assert(InitialSegmentSize > 0, "Initial segment size must be > 0."); 68Debug.Assert((InitialSegmentSize & (InitialSegmentSize - 1)) == 0, "Initial segment size must be a power of 2"); 69Debug.Assert(InitialSegmentSize <= MaxSegmentSize, "Initial segment size should be <= maximum."); 70Debug.Assert(MaxSegmentSize < int.MaxValue / 2, "Max segment size * 2 must be < int.MaxValue, or else overflow could occur."); 102Debug.Assert(segment != null, "Expected a non-null segment."); 112Debug.Assert(newSegmentSize > 0, "The max size should always be small enough that we don't overflow."); 179Debug.Assert(segment != null, "Expected a non-null segment."); 180Debug.Assert(array != null, "Expected a non-null item array."); 253Debug.Assert(segment != null, "Expected a non-null segment."); 254Debug.Assert(array != null, "Expected a non-null item array."); 368Debug.Assert(syncObj != null, "The syncObj parameter is null."); 390Debug.Assert((size & (size - 1)) == 0, "Size must be a power of 2"); 429Debug.Assert(queue != null, "Expected a non-null queue.");

src\libraries\Common\src\System\HexConverter.cs (2)

332Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 333Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters");

src\libraries\Common\src\System\IO\StringParser.cs (5)

177Debug.Assert(result == int.Parse(ExtractCurrent()), "Expected manually parsed result to match Parse result"); 222Debug.Assert(result == long.Parse(ExtractCurrent()), "Expected manually parsed result to match Parse result"); 253Debug.Assert(result == uint.Parse(ExtractCurrent()), "Expected manually parsed result to match Parse result"); 280Debug.Assert(result == ulong.Parse(ExtractCurrent()), "Expected manually parsed result to match Parse result"); 295Debug.Assert(result == char.Parse(ExtractCurrent()), "Expected manually parsed result to match Parse result");

src\libraries\Common\src\System\Number.Formatting.Common.cs (1)

820Debug.Assert(p >= spanPtr - 1, "Underflow");

src\libraries\Common\src\System\Number.NumberBuffer.cs (3)

68Debug.Assert(Digits[0] != '0', "Leading zeros should never be stored in a Number"); 83Debug.Assert(numDigits == DigitsCount, "Null terminator found in unexpected location in Number"); 84Debug.Assert(numDigits < Digits.Length, "Null terminator not found in Number");

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (1)

298Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed.");

src\libraries\System.Private.CoreLib\src\System\AppContext.cs (1)

157Debug.Assert(s_dataStore == null, "s_dataStore is not expected to be inited before Setup is called");

src\libraries\System.Private.CoreLib\src\System\Array.cs (1)

615Debug.Assert(hi - low >= 0, "Length overflow!");

src\libraries\System.Private.CoreLib\src\System\Buffers\SharedArrayPool.cs (2)

280Debug.Assert(t_tlsBuckets is null, $"Non-null {nameof(t_tlsBuckets)}"); 477Debug.Assert(array is not null, "No nulls should have been present in slots < _count.");

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\FormattingHelpers.CountDigits.cs (1)

103Debug.Assert(table.Length == 32, "Every result of uint.Log2(value) needs a long entry in the table.");

src\libraries\System.Private.CoreLib\src\System\Char.cs (1)

96Debug.Assert(IsLatin1(c), "char.GetLatin1UnicodeCategory(): c should be <= 00ff");

src\libraries\System.Private.CoreLib\src\System\Collections\Concurrent\ConcurrentQueue.cs (3)

335Debug.Assert(s._frozenForEnqueues, "Internal segment must be frozen as there's a following segment."); 577Debug.Assert(s._preservedForObservation, "Would have had to been preserved as a segment part of enumeration"); 578Debug.Assert(s._frozenForEnqueues, "Would have had to be frozen for enqueues as it's intermediate");

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ArraySortHelper.cs (5)

56Debug.Assert(comparer != null, "Check the arguments in the caller!"); 75Debug.Assert(array != null, "Check the arguments in the caller!"); 76Debug.Assert(index >= 0 && length >= 0 && (array.Length - index >= length), "Check the arguments in the caller!"); 326Debug.Assert(array != null, "Check the arguments in the caller!"); 327Debug.Assert(index >= 0 && length >= 0 && (array.Length - index >= length), "Check the arguments in the caller!");

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\Dictionary.cs (13)

199Debug.Assert(_comparer is not null, "The comparer should never be null for a reference type."); 285Debug.Assert(_buckets != null, "_buckets should be non-null"); 286Debug.Assert(_entries != null, "_entries should be non-null"); 407Debug.Assert(_entries != null, "expected entries to be != null"); 522Debug.Assert(entries != null, "expected entries to be non-null"); 602Debug.Assert((StartOfFreeList - entries[_freeList].next) >= -1, "shouldn't overflow because `next` cannot underflow"); 663Debug.Assert(entries != null, "expected entries to be non-null"); 725Debug.Assert((StartOfFreeList - entries[dictionary._freeList].next) >= -1, "shouldn't overflow because `next` cannot underflow"); 827Debug.Assert(_entries != null, "_entries should be non-null"); 880Debug.Assert(_entries != null, "entries should be non-null"); 907Debug.Assert((StartOfFreeList - _freeList) < 0, "shouldn't underflow because max hashtable length is MaxPrimeArrayLength = 0x7FEFFFFD(2146435069) _freelist underflow threshold 2147483646"); 953Debug.Assert(_entries != null, "entries should be non-null"); 982Debug.Assert((StartOfFreeList - _freeList) < 0, "shouldn't underflow because max hashtable length is MaxPrimeArrayLength = 0x7FEFFFFD(2146435069) _freelist underflow threshold 2147483646");

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\HashSet.cs (11)

199Debug.Assert(_buckets != null, "_buckets should be non-null"); 200Debug.Assert(_entries != null, "_entries should be non-null"); 222Debug.Assert(entries != null, "Expected _entries to be initialized"); 294Debug.Assert(entries != null, "entries should be non-null"); 324Debug.Assert((StartOfFreeList - _freeList) < 0, "shouldn't underflow because max hashtable length is MaxPrimeArrayLength = 0x7FEFFFFD(2146435069) _freelist underflow threshold 2147483646"); 927Debug.Assert(_comparer is not null, "The comparer should never be null for a reference type."); 967Debug.Assert(_entries != null, "_entries should be non-null"); 1097Debug.Assert(entries != null, "expected entries to be non-null"); 1161Debug.Assert((StartOfFreeList - entries![_freeList].Next) >= -1, "shouldn't overflow because `next` cannot underflow"); 1252Debug.Assert(_buckets != null, "_buckets shouldn't be null; callers should check first"); 1410Debug.Assert((_buckets != null) && (_count > 0), "_buckets was null but count greater than 0");

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\NonRandomizedStringEqualityComparer.cs (2)

87Debug.Assert(obj != null, "This implementation is only called from first-party collection types that guarantee non-null parameters."); 104Debug.Assert(obj != null, "This implementation is only called from first-party collection types that guarantee non-null parameters.");

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (1)

91Debug.Assert(index == 0, "Implementation currently only supports index == 0");

src\libraries\System.Private.CoreLib\src\System\Collections\HashHelpers.cs (1)

84Debug.Assert(MaxPrimeArrayLength == GetPrime(MaxPrimeArrayLength), "Invalid MaxPrimeArrayLength");

src\libraries\System.Private.CoreLib\src\System\Collections\Hashtable.cs (6)

281Debug.Assert(_loadsize < hashsize, "Invalid hashtable loadsize!"); 424Debug.Assert(!_isWriterInProgress, "Race condition detected in usages of Hashtable - multiple threads appear to be writing to a Hashtable instance simultaneously! Don't do that - use Hashtable.Synchronized."); 743Debug.Assert(_loadsize < newsize, "Our current implementation means this is not possible."); 790Debug.Assert(key != null, "key can't be null here!"); 940Debug.Assert(hashcode >= 0, "hashcode >= 0"); // make sure collision bit (sign bit) wasn't set. 972Debug.Assert(!_isWriterInProgress, "Race condition detected in usages of Hashtable - multiple threads appear to be writing to a Hashtable instance simultaneously! Don't do that - use Hashtable.Synchronized.");

src\libraries\System.Private.CoreLib\src\System\ComponentModel\DefaultValueAttribute.cs (1)

44Debug.Assert(IsSupported, "Runtime instantiation of this attribute is not allowed with trimming.");

src\libraries\System.Private.CoreLib\src\System\Convert.cs (2)

172Debug.Assert(value != null, "[Convert.DefaultToType]value!=null"); 2544Debug.Assert(Unsafe.AreSame(ref srcBeginning, ref Unsafe.As<ushort, byte>(ref dest)),

src\libraries\System.Private.CoreLib\src\System\DateTime.cs (5)

218Debug.Assert(kind == DateTimeKind.Local, "Internal Constructor is for local times only"); 819Debug.Assert(ticks <= MaxTicks, "Input parameters validated already"); 1149Debug.Assert(ticks <= MaxTicks, "Input parameters validated already"); 1162Debug.Assert(ticks <= MaxTicks, "Input parameters validated already"); 2053Debug.Assert(ticks <= MaxTicks, "Input parameters validated already");

src\libraries\System.Private.CoreLib\src\System\DateTimeOffset.cs (1)

994Debug.Assert(offset.Ticks >= MinOffset && offset.Ticks <= MaxOffset, "Offset not validated.");

src\libraries\System.Private.CoreLib\src\System\Decimal.cs (2)

630Debug.Assert(buffer.Length >= 16, "buffer.Length >= 16"); 640Debug.Assert(span.Length >= 16, "span.Length >= 16");

src\libraries\System.Private.CoreLib\src\System\DefaultBinder.cs (1)

1062Debug.Assert(cur1.IsStatic != cur2.IsStatic, "hierarchyDepth1 == hierarchyDepth2");

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Debug.cs (1)

90Assert(condition, message.ToStringAndClear());

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventProvider.cs (1)

486Debug.Assert(EtwAPIMaxRefObjCount == 8, $"{nameof(EtwAPIMaxRefObjCount)} must equal the number of fields in {nameof(EightObjects)}");

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (7)

1872Debug.Assert(data->Size >= 0 && data->Size % 2 == 0, "String size should be even"); 1877Debug.Assert(*(charPointer + i) != 0, "String may not contain null chars"); 1879Debug.Assert(*(charPointer + charLength) == 0, "String must be null terminated"); 2810Debug.Assert(EventListener.s_EventSources != null, "should be called within lock on EventListener.EventListenersLock which ensures s_EventSources to be initialized"); 4378Debug.Assert(eventSource.m_id == id, "Unexpected event source ID."); 4384Debug.Assert(allListeners.ContainsKey(dispatcher.m_Listener), "EventSource has a listener not on the global list."); 4394Debug.Assert(dispatcher != null, "Listener is not on all eventSources.");

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\ArrayTypeInfo.cs (1)

46Debug.Assert(value != null, "null accepted only for some overrides");

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\EnumerableTypeInfo.cs (1)

51Debug.Assert(value != null, "null accepted only for some overrides");

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\PropertyValue.cs (3)

132Debug.Assert(_scalarLength == 0, "This ReflectedValue refers to an unboxed value type, not a reference type or boxed value type."); 141Debug.Assert(_scalarLength > 0, "This ReflectedValue refers to a reference type or boxed value type, not an unboxed value type"); 150Debug.Assert(_scalarLength > 0, "This ReflectedValue refers to a reference type or boxed value type, not an unboxed value type");

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\TraceLoggingEventSource.cs (2)

632Debug.Assert(eventName != null, "GetOpcodeWithDefault should not returned Start when eventName is null"); 637Debug.Assert(eventName != null, "GetOpcodeWithDefault should not returned Stop when eventName is null");

src\libraries\System.Private.CoreLib\src\System\Environment.GetFolderPathCore.Unix.cs (3)

164Debug.Assert(!string.IsNullOrEmpty(homeDir), $"Expected non-empty homeDir"); 165Debug.Assert(!string.IsNullOrEmpty(key), $"Expected non-empty key"); 166Debug.Assert(!string.IsNullOrEmpty(fallback), $"Expected non-empty fallback");

src\libraries\System.Private.CoreLib\src\System\Globalization\Calendar.cs (2)

123Debug.Assert(BaseCalendarID != CalendarId.UNINITIALIZED_VALUE, "[Calendar.CurrentEraValue] Expected a real calendar ID"); 394Debug.Assert(offset >= 0, "Calendar.GetFirstDayWeekOfYear(): offset >= 0");

src\libraries\System.Private.CoreLib\src\System\Globalization\CharUnicodeInfo.cs (10)

56Debug.Assert(s != null, "s != null"); 57Debug.Assert(index >= 0 && index < s.Length, "index < s.Length"); 89Debug.Assert(bidiCategory == StrongBidiCategory.Other || bidiCategory == StrongBidiCategory.StrongLeftToRight || bidiCategory == StrongBidiCategory.StrongRightToLeft, "Unknown StrongBidiCategory value."); 365Debug.Assert(value != null, "value can not be null"); 366Debug.Assert(index < value.Length, "index < value.Length"); 377Debug.Assert(str != null, "str can not be null"); 378Debug.Assert(str.Length > 0, "str.Length > 0"); 379Debug.Assert(index >= 0 && index < str.Length, "index >= 0 && index < str.Length"); 411Debug.Assert(s != null, "s != null"); 412Debug.Assert((uint)index < (uint)s.Length, "index < s.Length");

src\libraries\System.Private.CoreLib\src\System\Globalization\CharUnicodeInfoData.cs (6)

17Debug.Assert(level1BitCount == 11, "Unexpected level 1 bit count."); 18Debug.Assert(level2BitCount == 5, "Unexpected level 2 bit count."); 19Debug.Assert(level3BitCount == 4, "Unexpected level 3 bit count."); 1436Debug.Assert(level1BitCount == 11, "Unexpected level 1 bit count."); 1437Debug.Assert(level2BitCount == 5, "Unexpected level 2 bit count."); 1438Debug.Assert(level3BitCount == 4, "Unexpected level 3 bit count.");

src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.cs (2)

221Debug.Assert(m_name != null, "CompareInfo.OnSerializing - expected m_name to be set already"); 238Debug.Assert(m_name != null, "CompareInfo.Name Expected _name to be set");

src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Nls.cs (3)

503Debug.Assert(actualSortKeyLength == 0, "LCMapStringEx should never return a negative value."); 555Debug.Assert(sortKeyLength == 0, "LCMapStringEx should never return a negative value."); 605Debug.Assert(((options & ~(CompareOptions.IgnoreCase |

src\libraries\System.Private.CoreLib\src\System\Globalization\CultureData.cs (15)

src\libraries\System.Private.CoreLib\src\System\Globalization\CultureData.Icu.cs (6)

205Debug.Assert(_sWindowsName != null, "[CultureData.IcuGetLocaleInfo] Expected _sWindowsName to be populated already"); 220Debug.Assert(localeName != null, "[CultureData.IcuGetLocaleInfo] Expected localeName to be not be null"); 245Debug.Assert(_sWindowsName != null, "[CultureData.IcuGetLocaleInfo(LocaleNumberData)] Expected _sWindowsName to be populated already"); 269Debug.Assert(_sWindowsName != null, "[CultureData.IcuGetLocaleInfo(LocaleGroupingData)] Expected _sWindowsName to be populated already"); 292Debug.Assert(_sWindowsName != null, "[CultureData.GetTimeFormatString(bool shortFormat)] Expected _sWindowsName to be populated already"); 444Debug.Assert(false, "[CultureData.IcuGetListSeparator] Unexpected ListSeparator value.");

src\libraries\System.Private.CoreLib\src\System\Globalization\CultureData.Nls.cs (6)

52Debug.Assert(_sRealName != null, "[CultureData.DoGetLocaleInfo] Expected _sRealName to be populated by already"); 79Debug.Assert(_sRealName != null, "[CultureData.DoGetLocaleInfoInt] Expected _sRealName to be populated by already"); 86Debug.Assert(_sRealName != null, "[CultureData.DoGetLocaleInfoInt] Expected _sRealName to be populated by already"); 99Debug.Assert(_sRealName != null, "[CultureData.DoGetLocaleInfoInt] Expected _sRealName to be populated by already"); 106Debug.Assert(_sRealName != null, "[CultureData.DoGetLocaleInfoInt] Expected _sRealName to be populated by already"); 178Debug.Assert(localeName != null, "[CultureData.GetLocaleInfoFromLCType] Expected localeName to be not be null");

src\libraries\System.Private.CoreLib\src\System\Globalization\CultureInfo.cs (3)

465Debug.Assert(s_InvariantCultureInfo != null, "[CultureInfo.InvariantCulture] s_InvariantCultureInfo is null"); 587Debug.Assert(_name != null, "[CultureInfo.DisplayName] Always expect _name to be set"); 814Debug.Assert(calType != CalendarId.GREGORIAN, "calType!=CalendarId.GREGORIAN");

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeFormat.cs (4)

166Debug.Assert(value >= 0, "DateTimeFormat.FormatDigits(): value >= 0"); 209Debug.Assert(dayOfWeek >= 0 && dayOfWeek <= 6, "dayOfWeek >= 0 && dayOfWeek <= 6"); 221Debug.Assert(month >= 1 && month <= 12, "month >=1 && month <= 12"); 262Debug.Assert(repeatCount != 3 || repeatCount != 4, "repeateCount should be 3 or 4");

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeFormatInfo.cs (38)

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeParse.cs (19)

97Debug.Assert(dtfi != null, "dtfi == null"); 190Debug.Assert(dtfi != null, "dtfi == null"); 553Debug.Assert(hourOffset >= 0 && hourOffset <= 99, "hourOffset >= 0 && hourOffset <= 99"); 554Debug.Assert(minuteOffset >= 0 && minuteOffset <= 99, "minuteOffset >= 0 && minuteOffset <= 99"); 2069Debug.Assert(raw.numCount >= 2, "raw.numCount >= 2"); 2091Debug.Assert(raw.numCount >= 3, "raw.numCount >= 3"); 2513Debug.Assert(dtfi != null, "dtfi == null"); 2809Debug.Assert(result.parsedDate.Kind == DateTimeKind.Unspecified, "result.parsedDate.Kind == DateTimeKind.Unspecified"); 3145Debug.Assert(minDigitLen > 0, "minDigitLen > 0"); 3146Debug.Assert(maxDigitLen < 9, "maxDigitLen < 9"); 3147Debug.Assert(minDigitLen <= maxDigitLen, "minDigitLen <= maxDigitLen"); 5390Debug.Assert(dtfi != null, "Expected non-null DateTimeFormatInfo"); 5429Debug.Assert(Index + count <= Length, "__DTString::Advance: Index + count <= len"); 5756Debug.Assert(Index >= 0 && Index < Length, "Index >= 0 && Index < len"); 5765Debug.Assert(Index >= 0 && Index < Length, "Index >= 0 && Index < len"); 5766Debug.Assert(char.IsAsciiDigit(Value[Index]), "IsDigit(Value[Index])"); 5918Debug.Assert(number >= 0 && number <= 9, "number >= 0 && number <= 9"); 5940Debug.Assert(sub.index == Index, "sub.index == Index"); 5941Debug.Assert(sub.index + sub.length <= Length, "sub.index + sub.length <= len");

src\libraries\System.Private.CoreLib\src\System\Globalization\HebrewCalendar.cs (1)

494Debug.Assert(numDays >= 1, "NumDays >= 1");

src\libraries\System.Private.CoreLib\src\System\Globalization\HebrewNumber.cs (1)

102Debug.Assert(Number > 0 && Number <= 999, "Number is out of range.");

src\libraries\System.Private.CoreLib\src\System\Globalization\IdnMapping.cs (12)

201Debug.Assert(count >= 1, "[IdnMapping.GetAscii] Expected 0 length strings to fail before now."); 372Debug.Assert(!char.IsLowSurrogate(unicode, basicCount), "[IdnMapping.punycode_encode]Unexpected low surrogate"); 449Debug.Assert(delta > 0, "[IdnMapping.cs]1 punycode_encode - delta overflowed int"); 463Debug.Assert(delta > 0, "[IdnMapping.cs]2 punycode_encode - delta overflowed int"); 474Debug.Assert(c_punycodeBase != t, "[IdnMapping.punycode_encode]Expected c_punycodeBase (36) to be != t"); 493Debug.Assert(delta > 0, "[IdnMapping.cs]3 punycode_encode - delta overflowed int"); 693Debug.Assert(w > 0, "[IdnMapping.punycode_decode]Expected w > 0"); 701Debug.Assert(c_punycodeBase != t, "[IdnMapping.punycode_decode]Expected t != c_punycodeBase (36)"); 711Debug.Assert((output.Length - iOutputAfterLastDot - numSurrogatePairs) + 1 > 0, 835Debug.Assert(numpoints != 0, "[IdnMapping.adapt]Expected non-zero numpoints."); 843Debug.Assert(delta + c_skew != 0, "[IdnMapping.adapt]Expected non-zero delta+skew."); 868Debug.Assert(d >= 0 && d < c_punycodeBase, "[IdnMapping.encode_digit]Expected 0 <= d < punycodeBase");

src\libraries\System.Private.CoreLib\src\System\Globalization\Normalization.Nls.cs (1)

100Debug.Assert(realLength > buffer.Length, "Buffer overflow should have iLength > cBuffer.Length");

src\libraries\System.Private.CoreLib\src\System\Globalization\RegionInfo.cs (1)

112Debug.Assert(_name != null, "Expected RegionInfo._name to be populated already");

src\libraries\System.Private.CoreLib\src\System\Globalization\SortKey.cs (2)

54Debug.Assert(key1Data != null, "key1Data != null"); 55Debug.Assert(key2Data != null, "key2Data != null");

src\libraries\System.Private.CoreLib\src\System\Globalization\TextElementEnumerator.cs (2)

21Debug.Assert(str != null, "TextElementEnumerator(): str != null"); 22Debug.Assert(startIndex >= 0 && startIndex <= str.Length, "TextElementEnumerator(): startIndex >= 0 && startIndex <= str.Length");

src\libraries\System.Private.CoreLib\src\System\Globalization\TextInfo.cs (2)

631Debug.Assert(charLen == 1 || charLen == 2, "[TextInfo.AddNonLetter] CharUnicodeInfo.InternalGetUnicodeCategory returned an unexpected charLen!"); 647Debug.Assert(charLen == 1 || charLen == 2, "[TextInfo.AddTitlecaseLetter] CharUnicodeInfo.InternalGetUnicodeCategory returned an unexpected charLen!");

src\libraries\System.Private.CoreLib\src\System\Globalization\TextInfo.Nls.cs (1)

42Debug.Assert(ret == pSourceLen, "Expected getting the same length of the original string");

src\libraries\System.Private.CoreLib\src\System\Globalization\TimeSpanFormat.cs (10)

src\libraries\System.Private.CoreLib\src\System\Globalization\TimeSpanParse.cs (4)

447Debug.Assert(_tokenCount == (_sepCount + _numCount), "tokenCount == (SepCount + NumCount)"); 631Debug.Assert(success, "Should have thrown on failure"); 653Debug.Assert(success, "Should have thrown on failure"); 675Debug.Assert(success, "Should have thrown on failure");

src\libraries\System.Private.CoreLib\src\System\Globalization\UmAlQuraCalendar.cs (6)

267Debug.Assert((HijriYear >= MinCalendarYear) && (HijriYear <= MaxCalendarYear), "Hijri year is out of range."); 268Debug.Assert(HijriMonth >= 1, "Hijri month is out of range."); 269Debug.Assert(HijriDay >= 1, "Hijri day is out of range."); 339Debug.Assert((time.Ticks >= s_minDate.Ticks) && (time.Ticks <= s_maxDate.Ticks), "Gregorian date is out of range."); 487Debug.Assert((year >= MinCalendarYear) && (year <= MaxCalendarYear), "Hijri year is out of range."); 497Debug.Assert((days == 354) || (days == 355), "Hijri year has to be 354 or 355 days.");

src\libraries\System.Private.CoreLib\src\System\Guid.cs (4)

259Debug.Assert(success, "GuidParseThrowStyle.All means throw on all failures"); 274Debug.Assert(success, "GuidParseThrowStyle.AllButOverflow means throw on all failures"); 333Debug.Assert(success, "GuidParseThrowStyle.AllButOverflow means throw on all failures"); 1172Debug.Assert(result && bytesWritten == guidString.Length, "Formatting guid should have succeeded.");

src\libraries\System.Private.CoreLib\src\System\IO\BinaryReader.cs (3)

159Debug.Assert(numBytes is 1 or 2, "BinaryReader::ReadOneChar assumes it's reading one or two bytes only."); 178Debug.Assert(charsRead < 2, "BinaryReader::ReadOneChar - assuming we only got 0 or 1 char, not 2!"); 458Debug.Assert(buffer.Length != 1, "length of 1 should use ReadByte.");

src\libraries\System.Private.CoreLib\src\System\IO\BufferedStream.cs (10)

199Debug.Assert(!(_writePos > 0 && _readPos != _readLen), "Read and Write buffers cannot both have data in them at the same time."); 368Debug.Assert(_writePos == 0, "BufferedStream: Write buffer must be empty in FlushRead!"); 407Debug.Assert(_readPos == 0 && _readLen == 0, 409Debug.Assert(_buffer != null && _bufferSize >= _writePos, 420Debug.Assert(_readPos == 0 && _readLen == 0, 422Debug.Assert(_buffer != null && _bufferSize >= _writePos, 499Debug.Assert(_readLen == _readPos, "The read buffer must now be empty"); 549Debug.Assert(_readLen == _readPos, "The read buffer must now be empty"); 1256Debug.Assert(_writePos == 0, "Write buffer must be empty if there's data in the read buffer"); 1295Debug.Assert(_writePos == 0, "Write buffer must be empty if there's data in the read buffer");

src\libraries\System.Private.CoreLib\src\System\IO\Enumeration\FileSystemEntry.Unix.cs (1)

85Debug.Assert(charsWritten > 0, "didn't write any chars to buffer");

src\libraries\System.Private.CoreLib\src\System\IO\File.cs (1)

106Debug.Assert(path != null, "File.Exists: GetFullPath returned null");

src\libraries\System.Private.CoreLib\src\System\IO\FileInfo.cs (1)

26Debug.Assert(!isNormalized || !PathInternal.IsPartiallyQualified(fullPath.AsSpan()), "should be fully qualified if normalized");

src\libraries\System.Private.CoreLib\src\System\IO\FileNotFoundException.cs (1)

53Debug.Assert(_message != null, "_message was null after calling SetMessageField");

src\libraries\System.Private.CoreLib\src\System\IO\MemoryStream.cs (3)

243Debug.Assert(_position + n >= 0, "_position + n >= 0"); // len is less than 2^31 -1. 330Debug.Assert(_position + n >= 0, "_position + n >= 0"); // len is less than 2^31 -1. 533Debug.Assert(_position >= _origin, "_position >= _origin");

src\libraries\System.Private.CoreLib\src\System\IO\Path.cs (7)

640Debug.Assert(result, "should never fail joining first two paths"); 705Debug.Assert(first.Length > 0 && second.Length > 0, "should have dealt with empty paths"); 716Debug.Assert(first.Length > 0 && second.Length > 0 && third.Length > 0, "should have dealt with empty paths"); 732Debug.Assert(first.Length > 0 && second.Length > 0 && third.Length > 0 && fourth.Length > 0, "should have dealt with empty paths"); 800Debug.Assert(byteCount == 8, $"Unexpected {nameof(byteCount)}"); 801Debug.Assert(chars.Length == 12, $"Unexpected {nameof(chars)}.Length"); 831Debug.Assert((b2 & 0xF8) == 0, "Unexpected set bits");

src\libraries\System.Private.CoreLib\src\System\IO\Path.Unix.cs (1)

68Debug.Assert(collapsedString.Length < path.Length || collapsedString.ToString() == path,

src\libraries\System.Private.CoreLib\src\System\IO\PinnedBufferMemoryStream.cs (1)

19Debug.Assert(array != null, "Array can't be null");

src\libraries\System.Private.CoreLib\src\System\IO\Strategies\BufferedFileStreamStrategy.cs (22)

28Debug.Assert(bufferSize > 1, "Buffering must not be enabled for smaller buffer sizes"); 62Debug.Assert(!(_writePos > 0 && _readPos != _readLen), "Read and Write buffers cannot both have data in them at the same time."); 162Debug.Assert((_readPos == 0 && _readLen == 0 && _writePos >= 0) || (_writePos == 0 && _readPos <= _readLen), 233Debug.Assert(_readPos == _readLen, "Read buffer should be empty!"); 301Debug.Assert(!_strategy.IsClosed, "FileStream ensures that strategy is not closed"); 302Debug.Assert((_readPos == 0 && _readLen == 0 && _writePos >= 0) || (_writePos == 0 && _readPos <= _readLen), 380Debug.Assert(_writePos == 0, "Win32FileStream must not have buffered write data here! Pipes should be unidirectional."); 427Debug.Assert(_readLen == _readPos, "The read buffer must now be empty"); 518Debug.Assert(_writePos == 0, "FlushWrite must set _writePos to 0"); 524Debug.Assert(_writePos == 0, "FileStream cannot have buffered data to write here! Your stream will be corrupted."); 598Debug.Assert(!_strategy.IsClosed, "FileStream ensures that strategy is not closed"); 599Debug.Assert((_readPos == 0 && _readLen == 0 && _writePos >= 0) || (_writePos == 0 && _readPos <= _readLen), 601Debug.Assert(_strategy.CanSeek || (_readPos == 0 && _readLen == 0), 721Debug.Assert(_writePos == 0, "FileStream cannot have buffered data to write here! Your stream will be corrupted."); 758Debug.Assert(!_strategy.IsClosed, "FileStream responsibility"); 759Debug.Assert((_readPos == 0 && _readLen == 0 && _writePos >= 0) || (_writePos == 0 && _readPos <= _readLen), 854Debug.Assert(_writePos == 0, "Write buffer must be empty if there's data in the read buffer"); 885Debug.Assert(_writePos == 0, "Write buffer must be empty if there's data in the read buffer"); 952Debug.Assert(_writePos == 0, "Write buffer must be empty in FlushRead!"); 965Debug.Assert(_readPos == 0 && _readLen == 0, "Read buffer must be empty in FlushWrite!"); 966Debug.Assert(_buffer != null && _bufferSize >= _writePos, "Write buffer must be allocated and write position must be in the bounds of the buffer in FlushWrite!"); 1044Debug.Assert(!_strategy.IsClosed, "FileStream ensures that strategy is not closed");

src\libraries\System.Private.CoreLib\src\System\IO\Strategies\OSFileStreamStrategy.cs (2)

189Debug.Assert(value >= 0, "value >= 0"); 192Debug.Assert(!_fileHandle.TryGetCachedLength(out _), "If length can be cached (file opened for reading, not shared for writing), it should be impossible to modify file length");

src\libraries\System.Private.CoreLib\src\System\IO\Stream.cs (6)

238Debug.Assert(thisTask != null && thisTask._stream != null, 520Debug.Assert(thisTask != null && thisTask._stream != null, 564Debug.Assert(asyncWaiter.IsCompletedSuccessfully, "The semaphore wait should always complete successfully."); 571Debug.Assert(t.IsCompletedSuccessfully, "The semaphore wait should always complete successfully."); 573Debug.Assert(rwt._stream != null, "Validates that this code isn't run a second time."); 593Debug.Assert(_asyncActiveSemaphore != null, "Must have been initialized in order to get here.");

src\libraries\System.Private.CoreLib\src\System\IO\StreamReader.cs (27)

src\libraries\System.Private.CoreLib\src\System\IO\StreamWriter.cs (1)

792Debug.Assert(n > 0, "StreamWriter::Write(char[], int, int) isn't making progress! This is most likely a race condition in user code.");

src\libraries\System.Private.CoreLib\src\System\IO\UnmanagedMemoryStream.cs (1)

382Debug.Assert(pos + nInt >= 0, "_position + n >= 0"); // len is less than 2^63 -1.

src\libraries\System.Private.CoreLib\src\System\Lazy.cs (1)

93Debug.Assert(_exceptionDispatch != null, "execution path is invalid");

src\libraries\System.Private.CoreLib\src\System\Marvin.cs (3)

48Debug.Assert(loopCount > 0, "Shouldn't reach this code path for small inputs."); 93Debug.Assert(count >= 4, "Only should've gotten here if the original count was >= 4."); 106Debug.Assert(count >= 4, "Only should've gotten here if the original count was >= 4.");

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.cs (1)

4590Debug.Assert(formatter != null, "An incorrectly written provider said it implemented ICustomFormatter, and then didn't");

src\libraries\System.Private.CoreLib\src\System\Number.Parsing.cs (1)

226Debug.Assert((styles & ~NumberStyles.Integer) == 0, "Only handles subsets of Integer format");

src\libraries\System.Private.CoreLib\src\System\Reflection\Emit\DynamicMethod.cs (4)

255Debug.Assert(owner == null && m == null, "owner and m cannot be set for transparent methods"); 261Debug.Assert(m != null || owner != null, "Constructor should ensure that either m or owner is set"); 262Debug.Assert(m == null || !m.Equals(s_anonymouslyHostedDynamicMethodsModule), "The user cannot explicitly use this assembly"); 263Debug.Assert(m == null || owner == null, "m and owner cannot both be set");

src\libraries\System.Private.CoreLib\src\System\Reflection\Emit\TypeBuilderInstantiation.cs (1)

34Debug.Assert(type != null, "this is only called from RuntimeType.MakeGenericType and TypeBuilder.MakeGenericType so 'type' cannot be null");

src\libraries\System.Private.CoreLib\src\System\Reflection\FieldAccessor.cs (1)

200Debug.Assert(false, "Unknown enum value");

src\libraries\System.Private.CoreLib\src\System\Reflection\MethodBaseInvoker.cs (1)

405Debug.Assert(!sigElementType.IsNullableOfT, "A true boxed Nullable<T> should never be here.");

src\libraries\System.Private.CoreLib\src\System\Resources\FastResourceComparer.cs (5)

75Debug.Assert(a != null && bytes != null, "FastResourceComparer::CompareOrdinal must have non-null params"); 76Debug.Assert(bCharLength * 2 <= bytes.Length, "FastResourceComparer::CompareOrdinal - numChars is too big!"); 111Debug.Assert((byteLen & 1) == 0, "CompareOrdinal is expecting a UTF-16 string length, which must be even!"); 112Debug.Assert(a != null && b != null, "Null args not allowed."); 113Debug.Assert(byteLen >= 0, "byteLen must be non-negative.");

src\libraries\System.Private.CoreLib\src\System\Resources\FileBasedResourceGroveler.cs (5)

20Debug.Assert(mediator != null, "mediator shouldn't be null; check caller"); 29Debug.Assert(culture != null, "culture shouldn't be null; check caller"); 64Debug.Assert(culture != null, "culture shouldn't be null; check caller"); 65Debug.Assert(fileName != null, "fileName shouldn't be null; check caller"); 88Debug.Assert(file != null, "file shouldn't be null; check caller");

src\libraries\System.Private.CoreLib\src\System\Resources\ManifestBasedResourceGroveler.cs (15)

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceManager.cs (2)

430Debug.Assert(culture != null, "culture != null"); 556Debug.Assert(asmTypeName != null, "asmTypeName was unexpectedly null");

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.Core.cs (5)

34Debug.Assert(stream != null, "Need a stream!"); 35Debug.Assert(stream.CanRead, "Stream should be readable!"); 36Debug.Assert(resCache != null, "Need a Dictionary!"); 178Debug.Assert(index >= 0 && index < _numResources, "Couldn't find data position within sorted data positions array!"); 181Debug.Assert(len >= 0 && len <= (int)_store.BaseStream.Length - dataPos + _dataSectionOffset, "Length was negative or outside the bounds of the file!");

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (20)

46Debug.Assert(value >= 0, "negative ResourceTypeCode. What?"); 201Debug.Assert(_nameHashes != null && _nameHashesPtr == null, "Internal state mangled."); 206Debug.Assert(_nameHashes == null && _nameHashesPtr != null, "Internal state mangled."); 217Debug.Assert(_namePositions != null && _namePositionsPtr == null, "Internal state mangled."); 222Debug.Assert(_namePositions == null && _namePositionsPtr != null, "Internal state mangled."); 258Debug.Assert(_store != null, "ResourceReader is closed!"); 339Debug.Assert(_store != null, "ResourceReader is closed!"); 382Debug.Assert(_store != null, "ResourceReader is closed!"); 453Debug.Assert(_store != null, "ResourceReader is closed!"); 477Debug.Assert(_store != null, "ResourceReader is closed!"); 539Debug.Assert(_store != null, "ResourceReader is closed!"); 540Debug.Assert(_version == 1, ".resources file was not a V1 .resources file!"); 621Debug.Assert(_store != null, "ResourceReader is closed!"); 622Debug.Assert(_version >= 2, ".resources file was not a V2 (or higher) .resources file!"); 729Debug.Assert(r == len, "ResourceReader needs to use a blocking read here. (Call _store.ReadBytes(len)?)"); 782Debug.Assert(_store != null, "ResourceReader is closed!"); 1001Debug.Assert(_typeTable[typeIndex] != null, "Should have found a type!"); 1032Debug.Assert(typeCode >= 0, "can't be negative"); 1037Debug.Assert(!string.Equals(typeCode.ToString(), "LastPrimitive"), "Change ResourceTypeCode metadata order so LastPrimitive isn't what Enum.ToString prefers."); 1043Debug.Assert(typeIndex >= 0 && typeIndex < _typeTable.Length, "TypeCode is broken or corrupted!");

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\AsyncMethodBuilderCore.cs (3)

146Debug.Assert(continuation != null, "Expected non-null continuation"); 147Debug.Assert(invokeAction != null, "Expected non-null invokeAction"); 148Debug.Assert(innerTask != null, "Expected non-null innerTask");

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\AsyncTaskMethodBuilderT.cs (3)

302Debug.Assert((m_stateFlags & (int)InternalTaskOptions.PromiseTask) != 0, "Expected state flags to already be configured."); 303Debug.Assert(m_stateObject is null, "Expected to be able to use the state object field for ExecutionContext."); 487Debug.Assert(task != null, "Expected non-null task");

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\AsyncVoidMethodBuilder.cs (1)

152Debug.Assert(context != null, "Must only be used with a non-null context.");

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\ConditionalWeakTable.cs (6)

294Debug.Assert(table != null, "Must provide a valid table"); 295Debug.Assert(Monitor.IsEntered(table._lock), "Must hold the _lock lock to construct the enumerator"); 296Debug.Assert(table._container != null, "Should not be used on a finalized table"); 297Debug.Assert(table._container.FirstFreeEntry > 0, "Should have returned an empty enumerator instead"); 301Debug.Assert(table._activeEnumeratorRefCount >= 0, "Should never have a negative ref count before incrementing"); 328Debug.Assert(table._activeEnumeratorRefCount >= 0, "Should never have a negative ref count after decrementing");

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\DefaultInterpolatedStringHandler.cs (2)

505Debug.Assert(provider is not CultureInfo || provider.GetFormat(typeof(ICustomFormatter)) is null, "Expected CultureInfo to not provide a custom formatter"); 526Debug.Assert(formatter != null, "An incorrectly written provider said it implemented ICustomFormatter, and then didn't");

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\PoolingAsyncValueTaskMethodBuilderT.cs (1)

408Debug.Assert(StateMachine is not null, $"Null {nameof(StateMachine)}");

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\TaskAwaiter.cs (10)

32Debug.Assert(task != null, "Constructing an awaiter requires a task to await."); 107Debug.Assert(taskCompleted, "With an infinite timeout, the task should have always completed."); 129Debug.Assert(task.IsCompleted, "Task must have been completed by now."); 130Debug.Assert(task.Status != TaskStatus.RanToCompletion, "Task should not be completed successfully."); 217Debug.Assert(task != null, "Need a task to wait on"); 218Debug.Assert(continuation != null, "Need a continuation to invoke when the wait completes"); 298Debug.Assert(task != null, "Constructing an awaiter requires a task to await."); 366Debug.Assert(task != null, "Constructing an awaitable requires a task to await."); 394Debug.Assert(task != null, "Constructing an awaiter requires a task to await."); 476Debug.Assert(task != null, "Constructing an awaiter requires a task to await.");

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\CollectionsMarshal.cs (2)

29Debug.Assert(items is not null, "Implementation depends on List<T> always having an array."); 37Debug.Assert(typeof(T[]) == list._items.GetType(), "Implementation depends on List<T> always using a T[] and not U[] where U : T.");

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshal.Unix.cs (1)

37Debug.Assert(bufferLength >= (s.Length + 1) * SystemMaxDBCSCharSize, "Insufficient buffer length passed to StringToAnsiString");

src\libraries\System.Private.CoreLib\src\System\Runtime\Loader\AssemblyLoadContext.cs (1)

279Debug.Assert(allContexts != null, "Creating the default context should have initialized the contexts collection.");

src\libraries\System.Private.CoreLib\src\System\Runtime\MemoryFailPoint.cs (1)

337Debug.Assert(Volatile.Read(ref s_failPointReservedMemory) >= 0, "Process-wide MemoryFailPoint reserved memory was negative!");

src\libraries\System.Private.CoreLib\src\System\Runtime\Serialization\SerializationInfo.cs (14)

src\libraries\System.Private.CoreLib\src\System\Runtime\Serialization\SerializationInfoEnumerator.cs (7)

38Debug.Assert(members != null, "[SerializationInfoEnumerator.ctor]members!=null"); 39Debug.Assert(info != null, "[SerializationInfoEnumerator.ctor]info!=null"); 40Debug.Assert(types != null, "[SerializationInfoEnumerator.ctor]types!=null"); 41Debug.Assert(numItems >= 0, "[SerializationInfoEnumerator.ctor]numItems>=0"); 42Debug.Assert(members.Length >= numItems, "[SerializationInfoEnumerator.ctor]members.Length>=numItems"); 43Debug.Assert(info.Length >= numItems, "[SerializationInfoEnumerator.ctor]info.Length>=numItems"); 44Debug.Assert(types.Length >= numItems, "[SerializationInfoEnumerator.ctor]types.Length>=numItems");

src\libraries\System.Private.CoreLib\src\System\Runtime\Versioning\VersioningHelper.cs (1)

166Debug.Assert(requires == SxSRequirements.None, "Computed a strange set of required resource scoping. It's probably wrong.");

src\libraries\System.Private.CoreLib\src\System\SearchValues\IndexOfAnyAsciiSearcher.cs (12)

src\libraries\System.Private.CoreLib\src\System\SearchValues\ProbabilisticWithAsciiCharSearchValues.cs (4)

57Debug.Assert(_inverseAsciiState.Lookup.Contains(0), "The inverse bitmap did not contain a 0."); 66Debug.Assert(!(Ssse3.IsSupported || PackedSimd.IsSupported) || !_inverseAsciiState.Lookup.Contains(0), 156Debug.Assert(_inverseAsciiState.Lookup.Contains(0), "The inverse bitmap did not contain a 0."); 165Debug.Assert(!(Ssse3.IsSupported || PackedSimd.IsSupported) || !_inverseAsciiState.Lookup.Contains(0),

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\AhoCorasickBuilder.cs (1)

44Debug.Assert(_nodes[0].MatchLength == 0, "The root node shouldn't have a match.");

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\RabinKarp.cs (2)

112Debug.Assert(span.Length <= MaxInputLength, "Teddy should have handled short inputs."); 164Debug.Assert(span.Length <= MaxInputLength, "Teddy should have handled long inputs.");

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\StringSearchValuesHelper.cs (1)

147Debug.Assert(matchStart == candidate[0], "This should only be called after the first character has been checked");

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\TeddyBucketizer.cs (2)

84Debug.Assert(bucketCount == 8, "This may change if we end up supporting the 'fat Teddy' variant."); 85Debug.Assert(values.Length > bucketCount, "Should be using a non-bucketized implementation.");

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\StringSearchValues.cs (1)

340Debug.Assert(newValuesCount > values.Length, "Shouldn't have been called if there were no letters present");

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\StringSearchValuesBase.cs (2)

30Debug.Assert(_uniqueValues is not null, "ContainsCore should be overridden if uniqueValues weren't provided."); 36Debug.Assert(_uniqueValues is not null, "GetValues should be overridden if uniqueValues weren't provided.");

src\libraries\System.Private.CoreLib\src\System\Security\SecureString.cs (2)

55Debug.Assert(str._buffer != null, "Expected other SecureString's buffer to be non-null"); 56Debug.Assert(str._encrypted, "Expected to be used only on encrypted SecureStrings");

src\libraries\System.Private.CoreLib\src\System\Security\SecurityElement.cs (7)

87Debug.Assert(iMax % 2 == 0, "Odd number of strings means the attr/value pairs were not added correctly"); 176Debug.Assert(iMax % 2 == 0, "Odd number of strings means the attr/value pairs were not added correctly"); 237Debug.Assert(iMax % 2 == 0, "Odd number of strings means the attr/value pairs were not added correctly"); 306Debug.Assert(iMax % 2 == 0, "Odd number of strings means the attr/value pairs were not added correctly"); 346Debug.Assert(iMax % 2 == 0, "Odd number of strings means the attr/value pairs were not added correctly"); 421Debug.Assert(iMax % 2 == 0, "Odd number of strings means the attr/value pairs were not added correctly"); 485Debug.Assert(iMax % 2 == 0, "Odd number of strings means the attr/value pairs were not added correctly");

src\libraries\System.Private.CoreLib\src\System\SpanHelpers.T.cs (32)

src\libraries\System.Private.CoreLib\src\System\String.Comparison.cs (6)

82Debug.Assert(strA._firstChar == strB._firstChar, 189Debug.Assert(*(a + 1) != *(b + 1), "This char must be different if we reach here!"); 820Debug.Assert(src[this.Length] == '\0', "src[this.Length] == '\\0'"); 821Debug.Assert(((int)src) % 4 == 0, "Managed string should start at 4 bytes boundary"); 855Debug.Assert(src[this.Length] == '\0', "src[this.Length] == '\\0'"); 856Debug.Assert(((int) src) % 4 == 0, "Managed string should start at 4 bytes boundary");

src\libraries\System.Private.CoreLib\src\System\String.cs (2)

536Debug.Assert(stringLength >= 0, "stringLength >= 0"); 547Debug.Assert(stringLength == doubleCheck,

src\libraries\System.Private.CoreLib\src\System\String.Manipulation.cs (3)

124Debug.Assert(position <= totalLength - s.Length, "We didn't allocate enough space for the result string!"); 2282Debug.Assert(startIndex >= 0 && startIndex <= this.Length, "StartIndex is out of range!"); 2283Debug.Assert(length >= 0 && startIndex <= this.Length - length, "length is out of range!");

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.CaseConversion.cs (2)

268Debug.Assert((nuint)(&pDest[i]) % expectedWriteAlignment == 0, "Destination buffer wasn't properly aligned!"); 275Debug.Assert(i <= elementCount, "We overran a buffer somewhere.");

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Utility.cs (64)

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Utility.Helpers.cs (1)

43Debug.Assert(!AllBytesInUInt32AreAscii(value), "Caller shouldn't provide an all-ASCII value.");

src\libraries\System.Private.CoreLib\src\System\Text\ASCIIEncoding.cs (14)

156Debug.Assert(charCount >= 0, "Caller shouldn't specify negative length buffer."); 157Debug.Assert(pChars is not null || charCount == 0, "Input pointer shouldn't be null if non-zero length specified."); 349Debug.Assert(charCount >= 0, "Caller shouldn't specify negative length buffer."); 350Debug.Assert(pChars is not null || charCount == 0, "Input pointer shouldn't be null if non-zero length specified."); 351Debug.Assert(byteCount >= 0, "Caller shouldn't specify negative length buffer."); 352Debug.Assert(pBytes is not null || byteCount == 0, "Input pointer shouldn't be null if non-zero length specified."); 408Debug.Assert(idx <= numElementsToConvert, "Somehow went beyond bounds of source or destination buffer?"); 498Debug.Assert(byteCount >= 0, "Caller shouldn't specify negative length buffer."); 499Debug.Assert(pBytes is not null || byteCount == 0, "Input pointer shouldn't be null if non-zero length specified."); 640Debug.Assert(byteCount >= 0, "Caller shouldn't specify negative length buffer."); 641Debug.Assert(pBytes is not null || byteCount == 0, "Input pointer shouldn't be null if non-zero length specified."); 642Debug.Assert(charCount >= 0, "Caller shouldn't specify negative length buffer."); 643Debug.Assert(pChars is not null || charCount == 0, "Input pointer shouldn't be null if non-zero length specified."); 696Debug.Assert(idx <= numElementsToConvert, "Somehow went beyond bounds of source or destination buffer?");

src\libraries\System.Private.CoreLib\src\System\Text\CompositeFormat.cs (1)

46Debug.Assert((segment.Literal is not null) ^ (segment.ArgIndex >= 0), "The segment should represent a literal or a format hole, but not both.");

src\libraries\System.Private.CoreLib\src\System\Text\Decoder.cs (1)

178Debug.Assert(result <= charCount, "Returned more chars than we have space for");

src\libraries\System.Private.CoreLib\src\System\Text\DecoderFallback.cs (2)

109Debug.Assert(byteStart != null, "[DecoderFallback.InternalFallback]Used InternalFallback without calling InternalInitialize"); 164Debug.Assert(byteStart != null, "[DecoderFallback.InternalFallback]Used InternalFallback without calling InternalInitialize");

src\libraries\System.Private.CoreLib\src\System\Text\DecoderNLS.cs (6)

227Debug.Assert(_fallbackBuffer is null || _fallbackBuffer.Remaining == 0, "Should have no data remaining in the fallback buffer."); 228Debug.Assert(HasLeftoverData, "Caller shouldn't invoke this routine unless there's leftover data in the decoder."); 268Debug.Assert(charCount >= 0, "Fallback buffer shouldn't have returned a negative char count."); 283Debug.Assert(_fallbackBuffer is null || _fallbackBuffer.Remaining == 0, "Should have no data remaining in the fallback buffer."); 284Debug.Assert(HasLeftoverData, "Caller shouldn't invoke this routine unless there's leftover data in the decoder."); 351Debug.Assert(combinedBufferBytesConsumed == combinedBuffer.Length, "We should be asked to persist the entire combined buffer.");

src\libraries\System.Private.CoreLib\src\System\Text\DecoderReplacementFallback.cs (1)

132Debug.Assert(_fallbackIndex < _strDefault.Length && _fallbackIndex >= 0,

src\libraries\System.Private.CoreLib\src\System\Text\Encoder.cs (1)

176Debug.Assert(result <= byteCount, "Returned more bytes than we have space for");

src\libraries\System.Private.CoreLib\src\System\Text\EncoderFallback.cs (2)

262Debug.Assert(byteCountThisIteration >= 0, "Encoding shouldn't have returned a negative byte count."); 299Debug.Assert(charStart != null,

src\libraries\System.Private.CoreLib\src\System\Text\EncoderLatin1BestFitFallback.cs (2)

142Debug.Assert(index + 1 < ArrayCharBestFit.Length, 163Debug.Assert(index + 1 < ArrayCharBestFit.Length,

src\libraries\System.Private.CoreLib\src\System\Text\EncoderNLS.cs (1)

288Debug.Assert(byteCount >= 0, "Encoding shouldn't have returned a negative byte count.");

src\libraries\System.Private.CoreLib\src\System\Text\EncoderReplacementFallback.cs (1)

160Debug.Assert(_fallbackIndex < _strDefault.Length && _fallbackIndex >= 0,

src\libraries\System.Private.CoreLib\src\System\Text\Encoding.cs (6)

711Debug.Assert(result <= byteCount, "[Encoding.GetBytes]Returned more bytes than we have space for"); 860Debug.Assert(result <= charCount, "[Encoding.GetChars]Returned more chars than we have space for"); 1287Debug.Assert(_fallbackBuffer.Remaining == 0, 1339Debug.Assert(_bytes < _byteEnd, "[EncodingCharBuffer.GetNextByte]Expected more date"); 1446Debug.Assert(moreBytesExpected >= 0, "[EncodingByteBuffer.AddByte]expected non-negative moreBytesExpected"); 1488Debug.Assert(_chars > _charStart ||

src\libraries\System.Private.CoreLib\src\System\Text\Encoding.Internal.cs (59)

src\libraries\System.Private.CoreLib\src\System\Text\Latin1Encoding.cs (10)

108Debug.Assert(charCount >= 0, "Caller shouldn't specify negative length buffer."); 109Debug.Assert(pChars is not null || charCount == 0, "Input pointer shouldn't be null if non-zero length specified."); 295Debug.Assert(charCount >= 0, "Caller shouldn't specify negative length buffer."); 296Debug.Assert(pChars is not null || charCount == 0, "Input pointer shouldn't be null if non-zero length specified."); 297Debug.Assert(byteCount >= 0, "Caller shouldn't specify negative length buffer."); 298Debug.Assert(pBytes is not null || byteCount == 0, "Input pointer shouldn't be null if non-zero length specified."); 601Debug.Assert(byteCount >= 0, "Caller shouldn't specify negative length buffer."); 602Debug.Assert(pBytes is not null || byteCount == 0, "Input pointer shouldn't be null if non-zero length specified."); 603Debug.Assert(charCount >= 0, "Caller shouldn't specify negative length buffer."); 604Debug.Assert(pChars is not null || charCount == 0, "Input pointer shouldn't be null if non-zero length specified.");

src\libraries\System.Private.CoreLib\src\System\Text\Latin1Utility.cs (22)

63Debug.Assert(0 < numCharsRead && numCharsRead <= SizeOfVectorInChars, "We should've made forward progress of at least one char."); 64Debug.Assert((nuint)numCharsRead <= bufferLength, "We shouldn't have read past the end of the input buffer."); 67Debug.Assert(pBuffer <= pFinalVectorReadPos, "Should be able to read at least one vector."); 71Debug.Assert((nuint)pBuffer % SizeOfVectorInChars == 0, "Vector read should be aligned."); 149Debug.Assert(totalNumBytesRead % sizeof(char) == 0, "Total number of bytes read should be even since we're working with chars."); 154Debug.Assert(!AllCharsInUInt32AreLatin1(currentUInt32), "Shouldn't have reached this point if we have an all-Latin-1 input."); 184Debug.Assert(Sse2.IsSupported, "Should've been checked by caller."); 185Debug.Assert(BitConverter.IsLittleEndian, "SSE2 assumes little-endian."); 240Debug.Assert(0 < numCharsRead && numCharsRead <= SizeOfVector128InChars, "We should've made forward progress of at least one char."); 241Debug.Assert((nuint)numCharsRead <= bufferLength, "We shouldn't have read past the end of the input buffer."); 370Debug.Assert(((nuint)pBuffer - (nuint)pOriginalBuffer) % 2 == 0, "Shouldn't have incremented any pointer by an odd byte count."); 425Debug.Assert(currentMask != 0, "Shouldn't be here unless we see non-Latin-1 data."); 433Debug.Assert(!AllCharsInUInt32AreLatin1(currentDWord), "Shouldn't be here unless we see non-Latin-1 data."); 550Debug.Assert(BitConverter.IsLittleEndian, "Assume little endian if SSE2 is supported."); 746Debug.Assert(!AllCharsInUInt32AreLatin1(utf16Data32BitsHigh), "Shouldn't have reached this point if we have an all-Latin-1 input."); 862Debug.Assert(0 < currentOffsetInElements && currentOffsetInElements <= SizeOfVector128, "We wrote at least 1 byte but no more than a whole vector."); 864Debug.Assert(currentOffsetInElements <= elementCount, "Shouldn't have overrun the destination buffer."); 865Debug.Assert(elementCount - currentOffsetInElements >= SizeOfVector128, "We should be able to run at least one whole vector."); 898Debug.Assert(((nuint)pLatin1Buffer + currentOffsetInElements) % SizeOfVector128 == 0, "Write should be aligned."); 933Debug.Assert(((nuint)pLatin1Buffer + currentOffsetInElements) % sizeof(ulong) == 0, "Destination should be ulong-aligned."); 1027Debug.Assert(elementCount - currentOffset < SizeOfVector128, "Case where 2 vectors remained should've been in the hot loop."); 1098Debug.Assert(elementCount - currentOffset < SizeOfVector, "Vectorized logic should result in less than a vector's length of data remaining.");

src\libraries\System.Private.CoreLib\src\System\Text\Rune.cs (3)

210Debug.Assert(!GlobalizationMode.Invariant, "This should've been checked by the caller."); 211Debug.Assert(textInfo != null, "This should've been checked by the caller."); 1199Debug.Assert(!value.IsAscii, "Shouldn't use this non-optimized code path for ASCII characters.");

src\libraries\System.Private.CoreLib\src\System\Text\StringBuilder.cs (25)

238Debug.Assert(m_ChunkOffset + m_ChunkChars.Length >= m_ChunkOffset, "The length of the string is greater than int.MaxValue."); 431Debug.Assert(newLen == chunk.m_ChunkChars.Length, "The new chunk should be larger or equal to the one it is replacing."); 441Debug.Assert(Length == value, "Something went wrong setting Length."); 684Debug.Assert(repeatCount > 0, "Invalid length; should have been validated by caller."); 706Debug.Assert(m_ChunkLength == 0, "A new block was not created."); 1024Debug.Assert(m_ChunkLength == 0, "A new block was not created."); 1057Debug.Assert(typeof(T).Assembly.Equals(typeof(object).Assembly), "Implementation trusts the results of TryFormat because T is expected to be something known"); 1070Debug.Assert(typeof(T).Assembly.Equals(typeof(object).Assembly), "Implementation trusts the results of TryFormat because T is expected to be something known"); 1413Debug.Assert(typeof(T).Assembly.Equals(typeof(object).Assembly), "Implementation trusts the results of TryFormat because T is expected to be something known"); 2102Debug.Assert(chunk != null, "chunk was null in replace"); 2126Debug.Assert(count >= 0, "count should never go negative"); 2182Debug.Assert(chunk != null || count == 0, "Chunks ended prematurely!"); 2268Debug.Assert(valueCount >= 0, "Invalid length; should have been validated by caller."); 2320Debug.Assert(m_ChunkLength == 0, "A new block was not created."); 2337Debug.Assert((uint)index <= (uint)Length, "Callers should check that index is a legal value."); 2391Debug.Assert(gapStart < sourceChunk.m_ChunkChars.Length, "gap starts at end of buffer. Should not happen"); 2392Debug.Assert(gapStart <= gapEnd, "negative gap size"); 2393Debug.Assert(gapEnd <= sourceChunk.m_ChunkLength, "gap too big"); 2402Debug.Assert(targetIndexInChunk <= targetChunk.m_ChunkLength, "gap not in chunk"); 2471Debug.Assert(chunk != null, "chunk should not be null at this point"); 2473Debug.Assert(lengthInChunk >= 0, "Index isn't in the chunk."); 2547Debug.Assert(Capacity == Length, nameof(ExpandByABlock) + " should only be called when there is no space left."); 2764Debug.Assert(chunk != null, "We fell off the beginning of the string!"); 2796Debug.Assert(chunk != null, "We fell off the beginning of the string!"); 3138Debug.Assert(formatter != null, "An incorrectly written provider said it implemented ICustomFormatter, and then didn't");

src\libraries\System.Private.CoreLib\src\System\Text\TranscodingStream.cs (1)

93Debug.Assert(disposing, "This type isn't finalizable.");

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf16Utility.Validation.cs (5)

26Debug.Assert(inputLength >= 0, "Input length must not be negative."); 27Debug.Assert(pInputBuffer != null || inputLength == 0, "Input length must be zero if input buffer pointer is null."); 91Debug.Assert((debugMask & 0b_1010_1010_1010_1010) == 0, "Shouldn't have set the 0x8000 bit of any element in 'charIsNonAscii'."); 193Debug.Assert((highSurrogatesMask & lowSurrogatesMask) == 0, 196Debug.Assert(((highSurrogatesMask | lowSurrogatesMask) & 0b_1010_1010_1010_1010u) == 0,

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8.cs (1)

658Debug.Assert(formatter is not null, "An incorrectly written provider said it implemented ICustomFormatter, and then didn't");

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Helpers.cs (3)

726Debug.Assert(IsFirstCharAtLeastThreeUtf8Bytes(value) && !IsFirstCharSurrogate(value), "First half of value should've been 0800..D7FF or E000..FFFF"); 727Debug.Assert(IsSecondCharAtLeastThreeUtf8Bytes(value) && !IsSecondCharSurrogate(value), "Second half of value should've been 0800..D7FF or E000..FFFF"); 761Debug.Assert(IsFirstCharAtLeastThreeUtf8Bytes(value) && !IsFirstCharSurrogate(value), "First half of value should've been 0800..D7FF or E000..FFFF");

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Transcoding.cs (10)

22Debug.Assert(inputLength >= 0, "Input length must not be negative."); 23Debug.Assert(pInputBuffer != null || inputLength == 0, "Input length must be zero if input buffer pointer is null."); 25Debug.Assert(outputCharsRemaining >= 0, "Destination length must not be negative."); 26Debug.Assert(pOutputBuffer != null || outputCharsRemaining == 0, "Destination length must be zero if destination buffer pointer is null."); 72Debug.Assert(pLastBufferPosProcessed < pInputBuffer, "Algorithm should've made forward progress since last read."); 842Debug.Assert(inputLength >= 0, "Input length must not be negative."); 843Debug.Assert(pInputBuffer != null || inputLength == 0, "Input length must be zero if input buffer pointer is null."); 845Debug.Assert(outputBytesRemaining >= 0, "Destination length must not be negative."); 846Debug.Assert(pOutputBuffer != null || outputBytesRemaining == 0, "Destination length must be zero if destination buffer pointer is null."); 906Debug.Assert(pLastBufferPosProcessed < pInputBuffer, "Algorithm should've made forward progress since last read.");

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Validation.cs (4)

26Debug.Assert(inputLength >= 0, "Input length must not be negative."); 27Debug.Assert(pInputBuffer != null || inputLength == 0, "Input length must be zero if input buffer pointer is null."); 77Debug.Assert(pLastBufferPosProcessed < pInputBuffer, "Algorithm should've made forward progress since last read."); 729Debug.Assert(pOriginalInputBuffer + originalInputLength == pInputBuffer, "About to return an unexpected value.");

src\libraries\System.Private.CoreLib\src\System\Text\UnicodeEncoding.cs (32)

338Debug.Assert(chars is not null, "[UnicodeEncoding.GetByteCount]chars!=null"); 339Debug.Assert(count >= 0, "[UnicodeEncoding.GetByteCount]count >=0"); 482Debug.Assert(chars > charStart, 550Debug.Assert(chars > charStart, 617Debug.Assert(fallbackBuffer is null || fallbackBuffer.Remaining == 0, 627Debug.Assert(chars is not null, "[UnicodeEncoding.GetBytes]chars!=null"); 628Debug.Assert(byteCount >= 0, "[UnicodeEncoding.GetBytes]byteCount >=0"); 629Debug.Assert(charCount >= 0, "[UnicodeEncoding.GetBytes]charCount >=0"); 630Debug.Assert(bytes is not null, "[UnicodeEncoding.GetBytes]bytes!=null"); 767Debug.Assert(chars > charStart, 835Debug.Assert(chars > charStart + 1 || bytes == byteStart, 864Debug.Assert(chars > charStart, 899Debug.Assert(chars > charStart, 966Debug.Assert((encoder is not null && !encoder.MustFlush) || charLeftOver == (char)0, 969Debug.Assert(fallbackBuffer is null || fallbackBuffer.Remaining == 0 || 978Debug.Assert(bytes is not null, "[UnicodeEncoding.GetCharCount]bytes!=null"); 979Debug.Assert(count >= 0, "[UnicodeEncoding.GetCharCount]count >=0"); 1013Debug.Assert(!decoder.InternalHasFallbackBuffer || decoder.FallbackBuffer.Remaining == 0, 1292Debug.Assert(fallbackBuffer is null || fallbackBuffer.Remaining == 0, 1301Debug.Assert(chars is not null, "[UnicodeEncoding.GetChars]chars!=null"); 1302Debug.Assert(byteCount >= 0, "[UnicodeEncoding.GetChars]byteCount >=0"); 1303Debug.Assert(charCount >= 0, "[UnicodeEncoding.GetChars]charCount >=0"); 1304Debug.Assert(bytes is not null, "[UnicodeEncoding.GetChars]bytes!=null"); 1320Debug.Assert(!decoder.InternalHasFallbackBuffer || decoder.FallbackBuffer.Remaining == 0, 1474Debug.Assert(bytes >= byteStart + 2 || chars == charStart, 1525Debug.Assert(bytes >= byteStart + 2 || chars == charStart, 1542Debug.Assert(bytes >= byteStart + 2 || chars == charStart, 1586Debug.Assert(bytes >= byteStart + 2 || chars == charStart, 1603Debug.Assert(bytes >= byteStart + 2 || chars == charStart, 1650Debug.Assert(bytes >= byteStart + 2 || chars == charStart, 1706Debug.Assert(!decoder.MustFlush || ((lastChar == (char)0) && (lastByte == -1)), 1716Debug.Assert(fallbackBuffer is null || fallbackBuffer.Remaining == 0,

src\libraries\System.Private.CoreLib\src\System\Text\UTF32Encoding.cs (25)

346Debug.Assert(chars is not null, "[UTF32Encoding.GetByteCount]chars!=null"); 347Debug.Assert(count >= 0, "[UTF32Encoding.GetByteCount]count >=0"); 410Debug.Assert(chars > charStart, 468Debug.Assert(fallbackBuffer.Remaining == 0, 478Debug.Assert(chars is not null, "[UTF32Encoding.GetBytes]chars!=null"); 479Debug.Assert(bytes is not null, "[UTF32Encoding.GetBytes]bytes!=null"); 480Debug.Assert(byteCount >= 0, "[UTF32Encoding.GetBytes]byteCount >=0"); 481Debug.Assert(charCount >= 0, "[UTF32Encoding.GetBytes]charCount >=0"); 551Debug.Assert(chars > charStart + 1 || bytes == byteStart, 579Debug.Assert(chars > charStart, 624Debug.Assert(chars > charStart, 661Debug.Assert(highSurrogate == 0 || (encoder is not null && !encoder.MustFlush), 679Debug.Assert(bytes is not null, "[UTF32Encoding.GetCharCount]bytes!=null"); 680Debug.Assert(count >= 0, "[UTF32Encoding.GetCharCount]count >=0"); 705Debug.Assert(fallbackBuffer.Remaining == 0, 812Debug.Assert(fallbackBuffer.Remaining == 0, 822Debug.Assert(chars is not null, "[UTF32Encoding.GetChars]chars!=null"); 823Debug.Assert(bytes is not null, "[UTF32Encoding.GetChars]bytes!=null"); 824Debug.Assert(byteCount >= 0, "[UTF32Encoding.GetChars]byteCount >=0"); 825Debug.Assert(charCount >= 0, "[UTF32Encoding.GetChars]charCount >=0"); 854Debug.Assert(fallbackBuffer.Remaining == 0, 919Debug.Assert(bytes >= byteStart + 4 || chars == charStart, 942Debug.Assert(bytes >= byteStart + 4 || chars == charStart, 959Debug.Assert(bytes >= byteStart + 4 || chars == charStart, 1027Debug.Assert(fallbackBuffer.Remaining == 0,

src\libraries\System.Private.CoreLib\src\System\Text\UTF7Encoding.cs (14)

382Debug.Assert(chars is not null, "[UTF7Encoding.GetByteCount]chars!=null"); 383Debug.Assert(count >= 0, "[UTF7Encoding.GetByteCount]count >=0"); 392Debug.Assert(byteCount >= 0, "[UTF7Encoding.GetBytes]byteCount >=0"); 393Debug.Assert(chars is not null, "[UTF7Encoding.GetBytes]chars!=null"); 394Debug.Assert(charCount >= 0, "[UTF7Encoding.GetBytes]charCount >=0"); 531Debug.Assert(count >= 0, "[UTF7Encoding.GetCharCount]count >=0"); 532Debug.Assert(bytes is not null, "[UTF7Encoding.GetCharCount]bytes!=null"); 541Debug.Assert(byteCount >= 0, "[UTF7Encoding.GetChars]byteCount >=0"); 542Debug.Assert(bytes is not null, "[UTF7Encoding.GetChars]bytes!=null"); 543Debug.Assert(charCount >= 0, "[UTF7Encoding.GetChars]charCount >=0"); 562Debug.Assert(!firstByte || decoder.bitCount <= 0, 840Debug.Assert(iCount < 0, "[DecoderUTF7FallbackBuffer.Fallback] Can't have recursive fallbacks"); 841Debug.Assert(bytesUnknown.Length == 1, "[DecoderUTF7FallbackBuffer.Fallback] Only possible fallback case should be 1 unknown byte"); 893Debug.Assert(iCount < 0, "[DecoderUTF7FallbackBuffer.InternalFallback] Can't have recursive fallbacks");

src\libraries\System.Private.CoreLib\src\System\Text\UTF8Encoding.cs (12)

206Debug.Assert(charCount >= 0, "Caller shouldn't specify negative length buffer."); 207Debug.Assert(pChars is not null || charCount == 0, "Input pointer shouldn't be null if non-zero length specified."); 396Debug.Assert(charCount >= 0, "Caller shouldn't specify negative length buffer."); 397Debug.Assert(pChars is not null || charCount == 0, "Input pointer shouldn't be null if non-zero length specified."); 398Debug.Assert(byteCount >= 0, "Caller shouldn't specify negative length buffer."); 399Debug.Assert(pBytes is not null || byteCount == 0, "Input pointer shouldn't be null if non-zero length specified."); 598Debug.Assert(byteCount >= 0, "Caller shouldn't specify negative length buffer."); 599Debug.Assert(pBytes is not null || byteCount == 0, "Input pointer shouldn't be null if non-zero length specified."); 600Debug.Assert(charCount >= 0, "Caller shouldn't specify negative length buffer."); 601Debug.Assert(pChars is not null || charCount == 0, "Input pointer shouldn't be null if non-zero length specified."); 716Debug.Assert(byteCount >= 0, "Caller shouldn't specify negative length buffer."); 717Debug.Assert(pBytes is not null || byteCount == 0, "Input pointer shouldn't be null if non-zero length specified.");

src\libraries\System.Private.CoreLib\src\System\Threading\CancellationTokenSource.cs (9)

342Debug.Assert(IsCancellationCompleted, "Expected cancellation to have finished"); 585Debug.Assert(this != s_neverCanceledSource, "This source should never be exposed via a CancellationToken."); 621Debug.Assert(node.Prev == null, "Nodes in the free list should all have a null Prev"); 679Debug.Assert(id != 0, "IDs should never be the reserved value 0."); 697Debug.Assert(IsCancellationCompleted, "Expected cancellation to have finished"); 733Debug.Assert(IsCancellationRequested, "ExecuteCallbackHandlers should only be called after setting IsCancellationRequested->true"); 1055Debug.Assert(node != null, "Expected non-null node"); 1056Debug.Assert(node.Registrations == this, "Expected node to come from this registrations instance"); 1203Debug.Assert(registrations != null, "Expected non-null parent registrations");

src\libraries\System.Private.CoreLib\src\System\Threading\EventWaitHandle.cs (1)

43Debug.Assert(result != null, "result should be non-null on success");

src\libraries\System.Private.CoreLib\src\System\Threading\ExecutionContext.cs (6)

298Debug.Assert(executionContext != null && !executionContext.m_isDefault, "ExecutionContext argument is Default."); 351Debug.Assert(Thread.CurrentThread._executionContext == null, "ThreadPool thread not on Default ExecutionContext."); 352Debug.Assert(Thread.CurrentThread._synchronizationContext == null, "ThreadPool thread not on Default SynchronizationContext."); 457Debug.Assert(current.m_localValues != null, "Only the default context should have null, and we shouldn't be here on the default context"); 471Debug.Assert(current.m_localValues != null, "Only the default context should have null, and we shouldn't be here on the default context"); 494Debug.Assert(current.m_localValues != null, "Only the default context should have null, and we shouldn't be here on the default context");

src\libraries\System.Private.CoreLib\src\System\Threading\IOCompletionCallbackHelper.cs (1)

28Debug.Assert(helper != null, "IOCompletionCallbackHelper cannot be null");

src\libraries\System.Private.CoreLib\src\System\Threading\ManualResetEventSlim.cs (8)

111Debug.Assert(value >= 0, "SpinCount is a restricted-width integer. The value supplied is outside the legal range."); 112Debug.Assert(value <= SpinCountState_MaxValue, "SpinCount is a restricted-width integer. The value supplied is outside the legal range."); 127Debug.Assert(value >= 0, "NumWaiters should never be less than zero. This indicates an internal error."); 194Debug.Assert(DEFAULT_SPIN_SP >= 0, "Internal error - DEFAULT_SPIN_SP is outside the legal range."); 195Debug.Assert(DEFAULT_SPIN_SP <= SpinCountState_MaxValue, "Internal error - DEFAULT_SPIN_SP is outside the legal range."); 240Debug.Assert(currentIsSet, 650Debug.Assert(obj is ManualResetEventSlim, "Expected a ManualResetEventSlim"); 672Debug.Assert((newBits | updateBitsMask) == updateBitsMask, "newBits do not fall within the updateBitsMask.");

src\libraries\System.Private.CoreLib\src\System\Threading\Mutex.cs (1)

53Debug.Assert(result != null, "result should be non-null on success");

src\libraries\System.Private.CoreLib\src\System\Threading\PeriodicTimer.cs (1)

218Debug.Assert(!_stopped, "Unexpectedly stopped without _signaled being true.");

src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.WaitThread.cs (1)

127Debug.Assert(current != null, "The wait thread to remove was not found in the list of thread pool wait threads.");

src\libraries\System.Private.CoreLib\src\System\Threading\ReaderWriterLockSlim.cs (6)

587Debug.Assert(_numWriteUpgradeWaiters == 0, "There can be at most one thread with the upgrade lock held."); 615Debug.Assert(lrwc != null, "Initialized based on _fIsReentrant earlier in the method"); 756Debug.Assert(lrwc != null, "Initialized based on _fIsReentrant earlier in the method"); 795Debug.Assert(_owners > 0, "ReleasingReaderLock: releasing lock and no read lock taken"); 843Debug.Assert((_owners & WRITER_HELD) > 0, "Calling ReleaseWriterLock when no write lock is held"); 1609Debug.Assert(_isLocked != 0, "Exiting spin lock that is not held");

src\libraries\System.Private.CoreLib\src\System\Threading\Semaphore.cs (1)

45Debug.Assert(result != null, "result should be non-null on success");

src\libraries\System.Private.CoreLib\src\System\Threading\SemaphoreSlim.cs (13)

352Debug.Assert(m_asyncTail is not null, "tail should not be null if head isn't"); 384Debug.Assert(!waitSuccessful || m_currentCount > 0, 631Debug.Assert(m_currentCount == 0, "m_currentCount should never be negative"); 644Debug.Assert(Monitor.IsEntered(m_lockObjAndDisposed), "Requires the lock be held"); 652Debug.Assert(m_asyncTail is null, "If head is null, so too should be tail"); 658Debug.Assert(m_asyncTail is not null, "If head is not null, neither should be tail"); 673Debug.Assert(task is not null, "Expected non-null task"); 674Debug.Assert(Monitor.IsEntered(m_lockObjAndDisposed), "Requires the lock be held"); 684Debug.Assert((m_asyncHead is null) == (m_asyncTail is null), "Head is null iff tail is null"); 700Debug.Assert(asyncWaiter is not null, "Waiter should have been constructed"); 701Debug.Assert(Monitor.IsEntered(m_lockObjAndDisposed), "Requires the lock be held"); 818Debug.Assert(m_asyncTail is not null, "tail should not be null if head isn't null"); 892Debug.Assert(obj is SemaphoreSlim, "Expected a SemaphoreSlim");

src\libraries\System.Private.CoreLib\src\System\Threading\SpinLock.cs (1)

117Debug.Assert(!IsThreadOwnerTrackingEnabled, "property should be false by now");

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\CachedCompletedInt32Task.cs (1)

26Debug.Assert(task.IsCompletedSuccessfully, "Expected that a stored last task completed successfully");

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\ConcurrentExclusiveSchedulerPair.cs (25)

200Debug.Assert(ReadyToComplete, "The block must be ready to complete to be here."); 213Debug.Assert(!localThis.m_completionState!.IsCompleted, "Completion should only happen once."); 219Debug.Assert(success, "Expected to complete completion task."); 230Debug.Assert(faultedTask != null && faultedTask.IsFaulted && faultedTask.Exception!.InnerExceptionCount > 0, 340else Debug.Assert(m_processingCount == EXCLUSIVE_PROCESSING_SENTINEL, "The processing count must be the sentinel if it's not >= 0."); 364Debug.Assert(m_processingCount == EXCLUSIVE_PROCESSING_SENTINEL, "Processing exclusive tasks requires being in exclusive mode."); 365Debug.Assert(!m_exclusiveTaskScheduler.m_tasks.IsEmpty, "Processing exclusive tasks requires tasks to be processed."); 370Debug.Assert(m_threadProcessingMode.Value == ProcessingMode.NotCurrentlyProcessing, 388Debug.Assert(m_threadProcessingMode.Value == ProcessingMode.ProcessingExclusiveTask, 399Debug.Assert(m_processingCount == EXCLUSIVE_PROCESSING_SENTINEL, "The processing mode should not have deviated from exclusive."); 412Debug.Assert(m_processingCount > 0, "Processing concurrent tasks requires us to be in concurrent mode."); 417Debug.Assert(m_threadProcessingMode.Value == ProcessingMode.NotCurrentlyProcessing, 446Debug.Assert(m_threadProcessingMode.Value == ProcessingMode.ProcessingConcurrentTasks, 457Debug.Assert(m_processingCount > 0, "The procesing mode should not have deviated from concurrent."); 524Debug.Assert(pair != null, "Scheduler must be associated with a valid pair."); 525Debug.Assert(processingMode == ProcessingMode.ProcessingConcurrentTasks || processingMode == ProcessingMode.ProcessingExclusiveTask, 527Debug.Assert( 547Debug.Assert(task != null, "Infrastructure should have provided a non-null task."); 563Debug.Assert(task != null, "Infrastructure should have provided a non-null task."); 573Debug.Assert(task != null, "Infrastructure should have provided a non-null task."); 647Debug.Assert(t.IsFaulted, "Task should be faulted due to the scheduler faulting it and throwing the exception."); 671Debug.Assert(scheduler != null, "Need a scheduler with which to construct the debug view."); 694Debug.Assert(pair != null, "Need a pair with which to construct the debug view."); 734Debug.Assert(syncObj != null, "The monitor object to check must be provided."); 735Debug.Assert(Monitor.IsEntered(syncObj) == held, "The locking scheme was not correctly followed.");

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\Future.cs (3)

402Debug.Assert(!IsCompleted, "The promise must not yet be completed."); 444Debug.Assert(!IsWaitNotificationEnabledOrNotRanToCompletion, 463Debug.Assert(IsCompletedSuccessfully, "Task<T>.Result getter: Expected result to have been set.");

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\FutureFactory.cs (22)

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\Sources\ManualResetValueTaskSourceCore.cs (4)

176Debug.Assert(storedContinuation is not null, $"{nameof(storedContinuation)} is null"); 224Debug.Assert(continuation is not null, $"{nameof(continuation)} is null"); 260Debug.Assert(executionContext is not null, $"{nameof(executionContext)} is null"); 319Debug.Assert(continuation is not null, $"{nameof(continuation)} is null");

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\Task.cs (86)

187Debug.Assert(task != null, "Null Task objects can't be added to the ActiveTasks collection"); 328Debug.Assert(promiseStyle, "Promise CTOR: promiseStyle was false"); 521Debug.Assert(m_contingentProperties == null || m_contingentProperties.m_capturedContext == null, 565Debug.Assert(illegalInternalOptions == 0, "TaskConstructorCore: Illegal internal options"); 569Debug.Assert(m_stateFlags == 0, "TaskConstructorCore: non-zero m_stateFlags"); 570Debug.Assert((((int)creationOptions) | (int)TaskStateFlags.OptionsMask) == (int)TaskStateFlags.OptionsMask, "TaskConstructorCore: options take too many bits"); 597Debug.Assert((internalOptions & InternalTaskOptions.ContinuationTask) == 0, "TaskConstructorCore: Did not expect to see cancelable token for continuation task."); 685Debug.Assert(((int)TaskStateFlags.OptionsMask & 1) == 1, "OptionsMask needs a shift in Options.get"); 740Debug.Assert((Options & (TaskCreationOptions)InternalTaskOptions.PromiseTask) != 0, 748Debug.Assert(success, "Tried to set enabled on completed Task"); 778Debug.Assert(tasks != null, "Expected non-null array of tasks"); 815Debug.Assert(isWaitNotificationEnabled, "Should only be called if the wait completion bit is set."); 833Debug.Assert(IsWaitNotificationEnabled, "Should only be called if the wait completion bit is set."); 874Debug.Assert(InternalCurrent == this, "Task.AddNewChild(): Called from an external context"); 895Debug.Assert(InternalCurrent == this, "Task.DisregardChild(): Called from an external context"); 898Debug.Assert(props.m_completionCountdown >= 2, "Task.DisregardChild(): Expected parent count to be >= 2"); 1043Debug.Assert(scheduler != null, "Task.InternalRunSynchronously(): null TaskScheduler"); 1113Debug.Assert( 1130Debug.Assert((m_stateFlags & (int)TaskStateFlags.Canceled) != 0, "Task.RunSynchronously: expected TaskStateFlags.Canceled to be set"); 1260Debug.Assert((e == null) || IsFaulted, "Task.Exception_get(): returning non-null value when not Faulted"); 1660Debug.Assert(m_taskScheduler != null, "expected a task scheduler to have been selected"); 1661Debug.Assert((m_stateFlags & (int)TaskStateFlags.Started) == 0, "task has already started"); 1683Debug.Assert(m_action != null, "Must have a delegate to be in ScheduleAndStart"); 1708Debug.Assert( 1728Debug.Assert(exceptionObject != null, "Task.AddException: Expected a non-null exception object"); 1739Debug.Assert(exceptionObject != null, "Task.AddException: Expected a non-null exception object"); 1747Debug.Assert( 1753Debug.Assert( 1845Debug.Assert(m_contingentProperties != null && m_contingentProperties.m_exceptionsHolder != null, "ExceptionRecorded should imply this"); 1863Debug.Assert(IsFaulted && ExceptionRecorded, "Must only be used when the task has faulted with exceptions."); 1871Debug.Assert(IsCanceled, "Must only be used when the task has canceled."); 1886Debug.Assert(IsCompleted, "ThrowIfExceptional(): Expected IsCompleted == true"); 2154Debug.Assert(childTask.IsCompleted, "ProcessChildCompletion was called for an uncompleted task"); 2156Debug.Assert(childTask.m_contingentProperties?.m_parent == this, "ProcessChildCompletion should only be called for a child of this task"); 2216Debug.Assert(task.IsCompleted, "Expected all tasks in list to be completed"); 2393Debug.Assert(m_action != null, "Null action in InnerInvoke()"); 2530Debug.Assert(!flowExecutionContext, "We already determined we're not required to flow context."); 2629Debug.Assert(waitResult, "expected wait to succeed"); 2785Debug.Assert((m_stateFlags & (int)TaskStateFlags.Faulted) == 0, "Task.Wait() completing when in Faulted state."); 3147Debug.Assert((Options & (TaskCreationOptions)InternalTaskOptions.PromiseTask) == 0, "Task.InternalCancel() did not expect promise-style task"); 3219Debug.Assert((m_stateFlags & IllegalFlags) == 0, "The continuation was in an invalid state."); 3220Debug.Assert((m_stateFlags & (int)TaskStateFlags.WaitingForActivation) != 0, "Expected continuation to be waiting for activation"); 3239Debug.Assert((Options & (TaskCreationOptions)InternalTaskOptions.PromiseTask) != 0, "Task.RecordInternalCancellationRequest(CancellationToken) only valid for promise-style task"); 3259Debug.Assert(edi != null, "Expected either an OCE or an EDI"); 3261Debug.Assert(oce != null, "Expected EDI to contain an OCE"); 3263Debug.Assert(oce.CancellationToken == tokenToRecord, 3274Debug.Assert((m_stateFlags & ((int)TaskStateFlags.Canceled | (int)TaskStateFlags.CompletionReserved)) != 0, "Task.CancellationCleanupLogic(): Task not canceled or reserved."); 3306Debug.Assert(this == InternalCurrent, "SetCancellationAcknowledged() should only be called while this is still the current task"); 3307Debug.Assert(IsCancellationRequested, "SetCancellationAcknowledged() should not be called if the task's CT wasn't signaled"); 3344Debug.Assert(exceptionObject != null, "Expected non-null exceptionObject argument"); 3347Debug.Assert( 3389Debug.Assert( 4433Debug.Assert(continuationTask != null, "Task.ContinueWithCore(): null continuationTask"); 4434Debug.Assert(scheduler != null, "Task.ContinueWithCore(): null scheduler"); 4435Debug.Assert(!continuationTask.IsCompleted, "Did not expect continuationTask to be completed"); 4517Debug.Assert(tc != null, "Expected non-null tc object in AddTaskContinuationComplex"); 4520Debug.Assert(oldValue is not null, "Expected non-null m_continuationObject object"); 4556Debug.Assert(oldValue == s_taskCompletionSentinel, "Expected m_continuationObject to be list or sentinel"); 4690Debug.Assert(waitResult, "expected wait to succeed"); 4710Debug.Assert(waitResult, "expected wait to succeed"); 5014Debug.Assert(exceptions != null, "Should have seen at least one exception"); 5040Debug.Assert(tasks != null, "Expected a non-null list of tasks"); 5041Debug.Assert(tasks.Count > 0, "Expected at least one task"); 5087Debug.Assert(count > 0, "Expected count > 0"); 5094Debug.Assert(_count >= 0, "Count should never go below 0"); 5137Debug.Assert(tasks.Length == 0 || waitResult != -1, "expected wait to succeed"); 5401Debug.Assert(succeeded, "This should always succeed on a new task."); 5415Debug.Assert(succeeded, "This should always succeed on a new task."); 5449Debug.Assert(succeeded, "This should always succeed on a new task."); 5463Debug.Assert(succeeded, "This should always succeed on a new task."); 5987Debug.Assert(tasks.Length != 0, "Expected a non-zero length task array"); 5988Debug.Assert(m_stateObject is null, "Expected to be able to use the state object field for faulted/canceled tasks."); 6133Debug.Assert(observedExceptions.Count > 0, "Expected at least one exception"); 6148Debug.Assert(_remainingToComplete >= 0, "Count should never go below 0"); 6339Debug.Assert(tasks != null, "Expected a non-null task array"); 6340Debug.Assert(tasks.Length > 0, "Expected a non-zero length task array"); 6378Debug.Assert(task != null, "Constituent task in WhenAll should never be null"); 6403Debug.Assert(observedExceptions.Count > 0, "Expected at least one exception"); 6424Debug.Assert(m_count >= 0, "Count should never go below 0"); 6625Debug.Assert(success, "Only one task should have gotten to this point, and thus this must be successful."); 7324Debug.Assert(outerTask != null, "Expected non-null outerTask"); 7378Debug.Assert(result, "Expected TrySetFromTask from inner task to succeed"); 7405Debug.Assert(task != null && task.IsCompleted, "Expected non-null, completed outer task"); 7406Debug.Assert(_state == STATE_WAITING_ON_OUTER_TASK, "We're in the wrong state!"); 7418Debug.Assert(result, "Expected TrySetFromTask from outer task to succeed"); 7435Debug.Assert(task != null && task.IsCompleted, "TrySetFromTask: Expected task to have completed.");

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\TaskCache.cs (1)

33Debug.Assert(ExclusiveInt32Max >= InclusiveInt32Min, "Expected max to be at least min");

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\TaskContinuation.cs (11)

18Debug.Assert(action is Action<Task> || action is Action<Task, object?>, 31Debug.Assert(antecedent != null, 64Debug.Assert(function is Func<Task, TResult> || function is Func<Task, object?, TResult>, 77Debug.Assert(antecedent != null, 110Debug.Assert(action is Action<Task<TAntecedentResult>> || action is Action<Task<TAntecedentResult>, object?>, 123Debug.Assert(antecedent != null, 156Debug.Assert(function is Func<Task<TAntecedentResult>, TResult> || function is Func<Task<TAntecedentResult>, object?, TResult>, 169Debug.Assert(antecedent != null, 274Debug.Assert(task != null, "TaskContinuation ctor: task is null"); 275Debug.Assert(scheduler != null, "TaskContinuation ctor: scheduler is null"); 292Debug.Assert(completedTask.IsCompleted, "ContinuationTask.Run(): completedTask not completed");

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\TaskExceptionHolder.cs (17)

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\TaskFactory.cs (7)

1554Debug.Assert((tasksCopy != null) && (tasksCopy.Length > 0), "Expected non-null task array with at least one element in it"); 1581Debug.Assert(_count >= 0, "Count should never go below 0"); 1624Debug.Assert((tasksCopy != null) && (tasksCopy.Length > 0), "Expected non-null task array with at least one element in it"); 1651Debug.Assert(_count >= 0, "Count should never go below 0"); 2274Debug.Assert(tasks != null, "Expected non-null collection of tasks"); 2309Debug.Assert(success, "Only one task should have gotten to this point, and thus this must be successful."); 2317Debug.Assert(tasks != null, "Should not have been nulled out yet.");

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\TaskScheduler.cs (1)

512Debug.Assert(scheduler != null, "Table returned an incorrect Count or CopyTo failed");

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\ValueTask.cs (1)

416Debug.Assert(valueTask._obj is null or Task or IValueTaskSource, "If the ValueTask<>'s backing object is an IValueTaskSource<TResult>, it must also be IValueTaskSource.");

src\libraries\System.Private.CoreLib\src\System\Threading\ThreadLocal.cs (4)

175Debug.Assert(id >= 0 || !_initialized, "expected id >= 0 if initialized"); 182Debug.Assert(_linkedSlot != null, "Should be non-null if not yet disposed"); 350Debug.Assert(ts_finalizationHelper != null, "Should have been initialized when this thread's slot array was created."); 393Debug.Assert(_linkedSlot != null, "Should only be null if disposed");

src\libraries\System.Private.CoreLib\src\System\Threading\ThreadPoolWorkQueue.cs (4)

699Debug.Assert(c > 0, "There must at least be a queue for this thread."); 1169Debug.Assert( 1178Debug.Assert( 1335Debug.Assert(helper != null, "Null state passed to PerformWaitOrTimerCallback!");

src\libraries\System.Private.CoreLib\src\System\Threading\Timer.cs (3)

203Debug.Assert(timer._dueTime != Timeout.UnsignedInfinite, "A timer in the list must have a valid due time."); 373Debug.Assert(timer._dueTime != Timeout.UnsignedInfinite, "Expected timer to be on a list."); 374Debug.Assert(timer._short != shortList, "Unnecessary if timer is already on the right list.");

src\libraries\System.Private.CoreLib\src\System\Threading\Win32ThreadPoolNativeOverlapped.cs (2)

194Debug.Assert(data._callback != null, "Does CompleteWithCallback called after Reset?"); 231Debug.Assert(data._callback != null, "Does OnExecutionContextCallback called after Reset?");

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.AdjustmentRule.cs (1)

243Diagnostics.Debug.Assert(daylightDelta <= MaxDaylightDelta && daylightDelta >= -MaxDaylightDelta,

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.cs (4)

312Debug.Assert(rule.NoDaylightTransitions, "GetPreviousAdjustmentRule should only be used with NoDaylightTransitions rules."); 612Debug.Assert(e is InvalidTimeZoneException, 1173Debug.Assert(result == null || ruleIndex.HasValue, "If an AdjustmentRule was found, ruleIndex should also be set."); 1895Debug.Assert(rule == null || ruleIndex.HasValue,

src\libraries\System.Private.CoreLib\src\System\WeakReference.T.cs (1)

169Debug.Assert(false, " WeakReference<T> finalizer should never run");

src\libraries\System.Reflection.Metadata\src\System\Reflection\Metadata\TypeNameParser.cs (1)

240Debug.Assert(nestedNameLength > 0, "TryGetTypeNameInfo should return error on zero lengths");

src\System\Buffer.CoreCLR.cs (3)

24Debug.Assert(len >= 0, "Negative length in memcpy!"); 31Debug.Assert((srcIndex >= 0) && (destIndex >= 0) && (len >= 0), "Index and length must be non-negative!"); 32Debug.Assert(src.Length - srcIndex >= len, "not enough bytes in src");

src\System\Delegate.CoreCLR.cs (1)

197Debug.Assert(currentType != null || _target.GetType().IsCOMObject, "The class hierarchy should declare the method");

src\System\Exception.CoreCLR.cs (1)

63Debug.Assert(_stackTrace != null, "_stackTrace shouldn't be null when this method is called");

src\System\MulticastDelegate.CoreCLR.cs (3)

56Debug.Assert(obj is MulticastDelegate, "Shouldn't have failed here since we already checked the types are the same!"); 94Debug.Assert(_invocationList is object[], "empty invocation list on multicast delegate"); 200Debug.Assert(!IsUnmanagedFunctionPtr(), "dynamic method and unmanaged fntptr delegate combined");

src\System\Reflection\Associates.cs (1)

67Debug.Assert(!associateMethodHandle.IsNullHandle(), "Failed to resolve associateRecord methodDef token");

src\System\Reflection\Emit\DynamicILGenerator.cs (1)

308Debug.Assert(opcode.Equals(OpCodes.Calli),

src\System\Reflection\Emit\RuntimeILGenerator.cs (11)

653Debug.Assert(opcode.Equals(OpCodes.Calli), 683Debug.Assert(opcode.Equals(OpCodes.Call) || 691Debug.Assert(opcode.Equals(OpCodes.Call) || 1309Debug.Assert(m_catchEndAddr[currentCatch - 1] == -1, "m_catchEndAddr[m_currentCatch-1] == -1"); 1326Debug.Assert(m_catchEndAddr[currentCatch - 1] == -1, "m_catchEndAddr[m_currentCatch-1] == -1"); 1372Debug.Assert(m_currentCatch > 0, "m_currentCatch > 0"); 1373Debug.Assert(m_catchAddr[m_currentCatch - 1] > 0, "m_catchAddr[m_currentCatch-1] > 0"); 1374Debug.Assert(m_catchEndAddr[m_currentCatch - 1] == -1, "m_catchEndAddr[m_currentCatch-1] == -1"); 1450Debug.Assert(m_currentCatch > 0, "m_currentCatch > 0"); 1451Debug.Assert(exc.m_currentCatch > 0, "exc.m_currentCatch > 0"); 1461Debug.Assert(exc.GetEndAddress() != GetEndAddress(),

src\System\Reflection\Emit\RuntimeMethodBuilder.cs (3)

586Debug.Assert(currentMethod == this, "We should have found this method in m_containingType.m_listMethods"); 587Debug.Assert(currentToken != 0, "The token should not be 0"); 594Debug.Assert(m_token == 0, "m_token should not have been initialized");

src\System\Reflection\Emit\RuntimeModuleBuilder.cs (2)

216Debug.Assert(!type.IsByRef, "Must not be ByRef. Get token from TypeSpec."); 217Debug.Assert(!type.IsGenericType || type.IsGenericTypeDefinition, "Must not have generic arguments.");

src\System\Reflection\Emit\RuntimeTypeBuilder.cs (1)

234Debug.Assert(destType is RuntimeType, "destType is not a runtime type, an EnumBuilder, or a TypeBuilder.");

src\System\Reflection\RuntimeCustomAttributeData.cs (1)

1985Debug.Assert(pca.BaseType == typeof(Attribute), "Pseudo CA Error - Incorrect base type");

src\System\Reflection\RuntimeLocalVariableInfo.cs (1)

16public override Type LocalType { get { Debug.Assert(_type != null, "type must be set!"); return _type; } }

src\System\Runtime\CompilerServices\CastHelpers.cs (1)

325Debug.Assert(mt != toTypeHnd, "The check for the trivial cases should be inlined by the JIT");

src\System\RuntimeHandles.cs (2)

210Debug.Assert(type.GetConstructor(Type.EmptyTypes) is ConstructorInfo c && c.IsPublic, 234Debug.Assert(type.GetConstructor(Type.EmptyTypes) is ConstructorInfo c && c.IsPublic,

src\System\RuntimeType.ActivatorCache.cs (1)

77Debug.Assert(Nullable.GetUnderlyingType(rt) != null,

src\System\RuntimeType.CoreCLR.cs (1)

4300Debug.Assert(!hit.Equals(key), "Key was already in CerHashtable! Potential race condition (or bug) in the Reflection cache?");

src\System\StubHelpers.cs (5)

33Debug.Assert(cbLength > 0, "Zero bytes returned from DoAnsiConversion in AnsiCharMarshaler.ConvertToNative"); 252Debug.Assert(length >= lengthInBytes + 6, "BSTR localloc'ed buffer is too small"); 361Debug.Assert(nbytesused >= 0 && nbytesused < nbytes, "Insufficient buffer allocated in VBByValStrMarshaler.ConvertToNative"); 904Debug.Assert(pvArrayMarshaler != IntPtr.Zero, "pvArrayMarshaler must not be null"); 1061Debug.Assert(length < allocSize, "Expected a length less than the allocated size");