< Summary

Information
Class: Hertzole.ScriptableValues.Helpers.Guard
Assembly: Hertzole.ScriptableValues
File(s): File 1: ./Packages/se.hertzole.scriptable-values/Runtime/Helpers/Guard.cs
File 2: ./Packages/se.hertzole.scriptable-values/Runtime/Helpers/Guard.ThrowHelper.cs
Tag: 52_28197466029
Line coverage
98%
Covered lines: 60
Uncovered lines: 1
Coverable lines: 61
Total lines: 190
Line coverage: 98.3%
Branch coverage
N/A
Covered branches: 0
Total branches: 0
Branch coverage: N/A
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
File 1: IsNotNull[T](...)0%220100%
File 1: IsNotReadOnly(...)0%3.13077.78%
File 1: IsNotReadOnly[T](...)0%110100%
File 1: IsNotReadOnly[T](...)0%110100%
File 1: ThrowIfNullAndNullsAreIllegal[T](...)0%330100%
File 1: IsGreaterThanOrEqualTo[T](...)0%220100%
File 1: IsLessThan[T](...)0%220100%
File 1: IsInRange[T](...)0%330100%
File 2: ThrowArgumentNullExceptionForIsNotNull[T](...)0%110100%
File 2: ThrowIsReadOnlyException(...)0%110100%
File 2: ThrowArgumentOutOfRangeExceptionForIsGreaterThanOrEqualTo[T](...)0%110100%
File 2: ThrowArgumentOutOfRangeExceptionForIsLessThan[T](...)0%110100%
File 2: ThrowArgumentOutOfRangeExceptionForIsInRange[T](...)0%110100%
File 2: AssertString(...)0%6.325062.5%

File(s)

./Packages/se.hertzole.scriptable-values/Runtime/Helpers/Guard.cs

#LineLine coverage
 1#nullable enable
 2
 3using System;
 4using System.Collections.Generic;
 5using System.Data;
 6using System.Runtime.CompilerServices;
 7using JetBrains.Annotations;
 8using UnityEngine;
 9
 10namespace Hertzole.ScriptableValues.Helpers
 11{
 12    internal static partial class Guard
 13    {
 14        /// <summary>
 15        ///     Throws an <see cref="ArgumentNullException" /> if the given value is null.
 16        /// </summary>
 17        /// <exception cref="ArgumentNullException" />
 18        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 19        public static void IsNotNull<T>([System.Diagnostics.CodeAnalysis.NotNull][NoEnumeration] T? value, string name) 
 2985620        {
 2985621            if (!EqualityHelper.IsNull(value))
 2973022            {
 2973023                return;
 24            }
 25
 12626            ThrowHelper.ThrowArgumentNullExceptionForIsNotNull<T>(name);
 2973027        }
 28
 29        /// <summary>
 30        ///     Throws a <see cref="ReadOnlyException" /> if the given value is read-only.
 31        /// </summary>
 32        /// <exception cref="ReadOnlyException" />
 33        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 34        public static void IsNotReadOnly(bool isReadOnly, string name)
 3439935        {
 36#if UNITY_EDITOR
 37            // Read-only does not matter when not playing.
 3439938            if (!Application.isPlaying)
 205239            {
 205240                return;
 41            }
 42#endif
 43
 3234744            if (!isReadOnly)
 3141745            {
 3141746                return;
 47            }
 48
 93049            ThrowHelper.ThrowIsReadOnlyException(name);
 3346950        }
 51
 52        /// <inheritdoc cref="IsNotReadOnly(bool, string)" />
 53        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 54        public static void IsNotReadOnly<T>(T value, string name) where T : ICanBeReadOnly
 3414155        {
 3414156            IsNotReadOnly(value.IsReadOnly, name);
 3325357        }
 58
 59        /// <inheritdoc cref="IsNotReadOnly" />
 60        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 61        public static void IsNotReadOnly<T>(ICollection<T> list, string name)
 24062        {
 24063            IsNotReadOnly(list.IsReadOnly, name);
 21064        }
 65
 66        /// <summary>
 67        ///     Throws an <see cref="ArgumentNullException" /> if the given value is null and T is a non-nullable type.
 68        /// </summary>
 69        /// <exception cref="ArgumentNullException" />
 70        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 71        public static void ThrowIfNullAndNullsAreIllegal<T>(object? value, string paramName)
 103872        {
 103873            if (default(T) == null || value != null)
 100274            {
 100275                return;
 76            }
 77
 3678            ThrowHelper.ThrowArgumentNullExceptionForIsNotNull<T>(paramName);
 100279        }
 80
 81        /// <summary>
 82        ///     Throws an <see cref="ArgumentOutOfRangeException" /> if the actual value is less than the compare value.
 83        /// </summary>
 84        /// <exception cref="ArgumentOutOfRangeException" />
 85        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 86        public static void IsGreaterThanOrEqualTo<T>(T actualValue, T compareValue, string paramName) where T : ICompara
 51687        {
 51688            if (actualValue.CompareTo(compareValue) >= 0)
 36089            {
 36090                return;
 91            }
 92
 15693            ThrowHelper.ThrowArgumentOutOfRangeExceptionForIsGreaterThanOrEqualTo(actualValue, compareValue, paramName);
 36094        }
 95
 96        /// <summary>
 97        ///     Throws an <see cref="ArgumentOutOfRangeException" /> if the actual value is not less than the compare va
 98        /// </summary>
 99        /// <exception cref="ArgumentOutOfRangeException" />
 100        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 101        public static void IsLessThan<T>(T actualValue, T compareValue, string paramName) where T : IComparable<T>
 18102        {
 18103            if (actualValue.CompareTo(compareValue) < 0)
 6104            {
 6105                return;
 106            }
 107
 12108            ThrowHelper.ThrowArgumentOutOfRangeExceptionForIsLessThan(compareValue, actualValue, paramName);
 6109        }
 110
 111        /// <summary>
 112        ///     Throws an <see cref="ArgumentOutOfRangeException" /> if the value is not in the specified range.
 113        /// </summary>
 114        /// <exception cref="ArgumentOutOfRangeException" />
 115        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 116        public static void IsInRange<T>(T value, T minValue, T maxValue, string paramName) where T : IComparable<T>
 876117        {
 876118            if (value.CompareTo(minValue) >= 0 && value.CompareTo(maxValue) <= 0)
 822119            {
 822120                return;
 121            }
 122
 54123            ThrowHelper.ThrowArgumentOutOfRangeExceptionForIsInRange(value, minValue, maxValue, paramName);
 822124        }
 125    }
 126}

./Packages/se.hertzole.scriptable-values/Runtime/Helpers/Guard.ThrowHelper.cs

#LineLine coverage
 1#nullable enable
 2
 3using System;
 4using System.Data;
 5using System.Diagnostics.CodeAnalysis;
 6
 7namespace Hertzole.ScriptableValues.Helpers
 8{
 9    internal partial class Guard
 10    {
 11        private static class ThrowHelper
 12        {
 13            /// <exception cref="ArgumentNullException" />
 14            [DoesNotReturn]
 15            public static void ThrowArgumentNullExceptionForIsNotNull<T>(string name)
 16216            {
 16217                throw new ArgumentNullException(name, $"{AssertString(name)} ({typeof(T).Name}) must be not null.");
 18            }
 19
 20            /// <exception cref="ReadOnlyException" />
 21            [DoesNotReturn]
 22            public static void ThrowIsReadOnlyException(string name)
 93023            {
 93024                throw new ReadOnlyException($"{AssertString(name)} is read-only and cannot be modified.");
 25            }
 26
 27            /// <exception cref="ArgumentOutOfRangeException" />
 28            [DoesNotReturn]
 29            public static void ThrowArgumentOutOfRangeExceptionForIsGreaterThanOrEqualTo<T>(T actualValue, T compareValu
 30                where T : IComparable<T>
 15631            {
 15632                throw new ArgumentOutOfRangeException(paramName, actualValue,
 33                    $"{AssertString(paramName)} must be greater than or equal to {AssertString(compareValue)} (Was {Asse
 34            }
 35
 36            /// <exception cref="ArgumentOutOfRangeException" />
 37            [DoesNotReturn]
 38            public static void ThrowArgumentOutOfRangeExceptionForIsLessThan<T>(T actualValue, T compareValue, string pa
 39                where T : IComparable<T>
 1240            {
 1241                throw new ArgumentOutOfRangeException(paramName, actualValue,
 42                    $"{AssertString(paramName)} must be less than {AssertString(compareValue)} (Was {AssertString(actual
 43            }
 44
 45            /// <exception cref="ArgumentOutOfRangeException" />
 46            [DoesNotReturn]
 47            public static void ThrowArgumentOutOfRangeExceptionForIsInRange<T>(T value, T minValue, T maxValue, string p
 5448            {
 5449                throw new ArgumentOutOfRangeException(paramName, value,
 50                    $"{AssertString(paramName)} must be between {AssertString(minValue)} and {AssertString(maxValue)} (W
 51            }
 52
 53            private static string AssertString(object? obj)
 181254            {
 181255                return obj switch
 56                {
 131457                    string _ => $"\"{obj}\"",
 058                    null => "null",
 49859                    _ => $"<{obj}>"
 60                };
 181261            }
 62        }
 63    }
 64}
Generated by: ReportGenerator 5.5.10.0
06/25/2026 - 20:21:10
GitHub | reportgenerator.io

Methods/Properties

IsNotNull[T](T, System.String)
IsNotReadOnly(System.Boolean, System.String)
IsNotReadOnly[T](T, System.String)
IsNotReadOnly[T](System.Collections.Generic.ICollection[T], System.String)
ThrowIfNullAndNullsAreIllegal[T](System.Object, System.String)
IsGreaterThanOrEqualTo[T](T, T, System.String)
IsLessThan[T](T, T, System.String)
IsInRange[T](T, T, T, System.String)
ThrowArgumentNullExceptionForIsNotNull[T](System.String)
ThrowIsReadOnlyException(System.String)
ThrowArgumentOutOfRangeExceptionForIsGreaterThanOrEqualTo[T](T, T, System.String)
ThrowArgumentOutOfRangeExceptionForIsLessThan[T](T, T, System.String)
ThrowArgumentOutOfRangeExceptionForIsInRange[T](T, T, T, System.String)
AssertString(System.Object)