13318089130

Committed 13 Feb 2025 10:13PM UTC coverage: 57.398% (+0.004%) from 57.394%

Build # 13318089130

Build Type

Pull #2134

github

Committed by

jas88

Commit Message

Update ChildProviderTests.cs

Fix up TestUpTo method

Pull Request Pull Request #2134: CodeQL fixups

Run Details

11346 of 21308 branches covered (53.25%)

Branch coverage included in aggregate %.

104 of 175 new or added lines in 45 files covered. (59.43%)

362 existing lines in 23 files now uncovered.

32218 of 54590 relevant lines covered (59.02%)

17091.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/Rdmp.Core/ReusableLibraryCode/Annotations/Annotations.cs

﻿// Copyright (c) The University of Dundee 2018-2019
// This file is part of the Research Data Management Platform (RDMP).
// RDMP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
// RDMP is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along with RDMP. If not, see <https://www.gnu.org/licenses/>.

using System;

namespace Rdmp.Core.ReusableLibraryCode.Annotations;

/// <summary>
/// Indicates that the value of the marked element could be <c>null</c> sometimes,
/// so the check for <c>null</c> is necessary before its usage
/// </summary>
/// <example><code>
/// [CanBeNull] public object Test() { return null; }
/// public void UseTest() {
///   var p = Test();
///   var s = p.ToString(); // Warning: Possible 'System.NullReferenceException'
/// }
/// </code></example>
[AttributeUsage(
    AttributeTargets.Method | AttributeTargets.Parameter |
    AttributeTargets.Property | AttributeTargets.Delegate |
    AttributeTargets.Field, AllowMultiple = false, Inherited = true)]
public sealed class CanBeNullAttribute : Attribute
{
}

/// <summary>
/// Indicates that the value of the marked element could never be <c>null</c>
/// </summary>
/// <example><code>
/// [NotNull] public object Foo() {
///   return null; // Warning: Possible 'null' assignment
/// }
/// </code></example>
[AttributeUsage(
    AttributeTargets.Method | AttributeTargets.Parameter |
    AttributeTargets.Property | AttributeTargets.Delegate |
    AttributeTargets.Field, AllowMultiple = false, Inherited = true)]
public sealed class NotNullAttribute : Attribute
{
}

/// <summary>
/// Indicates that the method is contained in a type that implements
/// <see cref="System.ComponentModel.INotifyPropertyChanged"/> interface
/// and this method is used to notify that some property value changed
/// </summary>
/// <remarks>
/// The method should be non-static and conform to one of the supported signatures:
/// <list>
/// <item><c>NotifyChanged(string)</c></item>
/// <item><c>NotifyChanged(params string[])</c></item>
/// <item><c>NotifyChanged{T}(Expression{Func{T}})</c></item>
/// <item><c>NotifyChanged{T,U}(Expression{Func{T,U}})</c></item>
/// <item><c>SetProperty{T}(ref T, T, string)</c></item>
/// </list>
/// </remarks>
/// <example><code>
/// public class Foo : INotifyPropertyChanged {
///   public event PropertyChangedEventHandler PropertyChanged;
///   [NotifyPropertyChangedInvocator]
///   protected virtual void NotifyChanged(string propertyName) { ... }
///
///   private string _name;
///   public string Name {
///     get { return _name; }
///     set { _name = value; NotifyChanged("LastName"); /* Warning */ }
///   }
/// }
/// </code>
/// Examples of generated notifications:
/// <list>
/// <item><c>NotifyChanged("Property")</c></item>
/// <item><c>NotifyChanged(() =&gt; Property)</c></item>
/// <item><c>NotifyChanged((VM x) =&gt; x.Property)</c></item>
/// <item><c>SetProperty(ref myField, value, "Property")</c></item>
/// </list>
/// </example>
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
public sealed class NotifyPropertyChangedInvocatorAttribute : Attribute
{
    public NotifyPropertyChangedInvocatorAttribute()
    {
    }

    public NotifyPropertyChangedInvocatorAttribute(string parameterName)
    {
        ParameterName = parameterName;
    }

    public string ParameterName { get; private set; }
}

/// <summary>
/// Indicates that the marked symbol is used implicitly
/// (e.g. via reflection, in external library), so this symbol
/// will not be marked as unused (as well as by other usage inspections)
/// </summary>
[AttributeUsage(AttributeTargets.All, AllowMultiple = false, Inherited = true)]
public sealed class UsedImplicitlyAttribute : Attribute
{
    public UsedImplicitlyAttribute(
        ImplicitUseKindFlags useKindFlags = ImplicitUseKindFlags.Default,
        ImplicitUseTargetFlags targetFlags = ImplicitUseTargetFlags.Default)
    {
        UseKindFlags = useKindFlags;
        TargetFlags = targetFlags;
    }

    public ImplicitUseKindFlags UseKindFlags { get; }
    public ImplicitUseTargetFlags TargetFlags { get; }
}

[Flags]
public enum ImplicitUseKindFlags
{
    Default = Access | Assign | InstantiatedWithFixedConstructorSignature,

    /// <summary>Only entity marked with attribute considered used</summary>
    Access = 1,

    /// <summary>Indicates implicit assignment to a member</summary>
    Assign = 2,

    /// <summary>
    /// Indicates implicit instantiation of a type with fixed constructor signature.
    /// That means any unused constructor parameters won't be reported as such.
    /// </summary>
    InstantiatedWithFixedConstructorSignature = 4,

    /// <summary>Indicates implicit instantiation of a type</summary>
    InstantiatedNoFixedConstructorSignature = 8
}

/// <summary>
/// Specify what is considered used implicitly
/// </summary>
[Flags]
public enum ImplicitUseTargetFlags
{
    Itself = 1,
    Default = Itself,

    /// <summary>Members of entity marked with attribute are considered used</summary>
    Members = 2,

    /// <summary>Entity marked with attribute and all its members considered used</summary>
    WithMembers = Itself | Members
}

1	// Copyright (c) The University of Dundee 2018-2019
2	// This file is part of the Research Data Management Platform (RDMP).
3	// RDMP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
4	// RDMP is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
5	// You should have received a copy of the GNU General Public License along with RDMP. If not, see <https://www.gnu.org/licenses/>.
6
7	using System;
8
9	namespace Rdmp.Core.ReusableLibraryCode.Annotations;
10
11	/// <summary>
12	/// Indicates that the value of the marked element could be <c>null</c> sometimes,
13	/// so the check for <c>null</c> is necessary before its usage
14	/// </summary>
15	/// <example><code>
16	/// [CanBeNull] public object Test() { return null; }
17	/// public void UseTest() {
18	/// var p = Test();
19	/// var s = p.ToString(); // Warning: Possible 'System.NullReferenceException'
20	/// }
21	/// </code></example>
22	[AttributeUsage(
23	AttributeTargets.Method \| AttributeTargets.Parameter \|
24	AttributeTargets.Property \| AttributeTargets.Delegate \|
25	AttributeTargets.Field, AllowMultiple = false, Inherited = true)]
26	public sealed class CanBeNullAttribute : Attribute
27	{
28	}
29
30	/// <summary>
31	/// Indicates that the value of the marked element could never be <c>null</c>
32	/// </summary>
33	/// <example><code>
34	/// [NotNull] public object Foo() {
35	/// return null; // Warning: Possible 'null' assignment
36	/// }
37	/// </code></example>
38	[AttributeUsage(
39	AttributeTargets.Method \| AttributeTargets.Parameter \|
40	AttributeTargets.Property \| AttributeTargets.Delegate \|
41	AttributeTargets.Field, AllowMultiple = false, Inherited = true)]
42	public sealed class NotNullAttribute : Attribute
43	{
44	}
45
46	/// <summary>
47	/// Indicates that the method is contained in a type that implements
48	/// <see cref="System.ComponentModel.INotifyPropertyChanged"/> interface
49	/// and this method is used to notify that some property value changed
50	/// </summary>
51	/// <remarks>
52	/// The method should be non-static and conform to one of the supported signatures:
53	/// <list>
54	/// <item><c>NotifyChanged(string)</c></item>
55	/// <item><c>NotifyChanged(params string[])</c></item>
56	/// <item><c>NotifyChanged{T}(Expression{Func{T}})</c></item>
57	/// <item><c>NotifyChanged{T,U}(Expression{Func{T,U}})</c></item>
58	/// <item><c>SetProperty{T}(ref T, T, string)</c></item>
59	/// </list>
60	/// </remarks>
61	/// <example><code>
62	/// public class Foo : INotifyPropertyChanged {
63	/// public event PropertyChangedEventHandler PropertyChanged;
64	/// [NotifyPropertyChangedInvocator]
65	/// protected virtual void NotifyChanged(string propertyName) { ... }
66	///
67	/// private string _name;
68	/// public string Name {
69	/// get { return _name; }
70	/// set { _name = value; NotifyChanged("LastName"); /* Warning */ }
71	/// }
72	/// }
73	/// </code>
74	/// Examples of generated notifications:
75	/// <list>
76	/// <item><c>NotifyChanged("Property")</c></item>
77	/// <item><c>NotifyChanged(() => Property)</c></item>
78	/// <item><c>NotifyChanged((VM x) => x.Property)</c></item>
79	/// <item><c>SetProperty(ref myField, value, "Property")</c></item>
80	/// </list>
81	/// </example>
82	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
83	public sealed class NotifyPropertyChangedInvocatorAttribute : Attribute
84	{
85	public NotifyPropertyChangedInvocatorAttribute()	×
86	{
87	}	×
88
UNCOV 89	public NotifyPropertyChangedInvocatorAttribute(string parameterName)	×
90	{
UNCOV 91	ParameterName = parameterName;	×
UNCOV 92	}	×
93
UNCOV 94	public string ParameterName { get; private set; }	×
95	}
96
97	/// <summary>
98	/// Indicates that the marked symbol is used implicitly
99	/// (e.g. via reflection, in external library), so this symbol
100	/// will not be marked as unused (as well as by other usage inspections)
101	/// </summary>
102	[AttributeUsage(AttributeTargets.All, AllowMultiple = false, Inherited = true)]
103	public sealed class UsedImplicitlyAttribute : Attribute
104	{
105	public UsedImplicitlyAttribute(	×
106	ImplicitUseKindFlags useKindFlags = ImplicitUseKindFlags.Default,	×
107	ImplicitUseTargetFlags targetFlags = ImplicitUseTargetFlags.Default)	×
108	{
109	UseKindFlags = useKindFlags;	×
110	TargetFlags = targetFlags;	×
UNCOV 111	}	×
112
UNCOV 113	public ImplicitUseKindFlags UseKindFlags { get; }	×
UNCOV 114	public ImplicitUseTargetFlags TargetFlags { get; }	×
115	}
116
117	[Flags]
118	public enum ImplicitUseKindFlags
119	{
120	Default = Access \| Assign \| InstantiatedWithFixedConstructorSignature,
121
122	/// <summary>Only entity marked with attribute considered used</summary>
123	Access = 1,
124
125	/// <summary>Indicates implicit assignment to a member</summary>
126	Assign = 2,
127
128	/// <summary>
129	/// Indicates implicit instantiation of a type with fixed constructor signature.
130	/// That means any unused constructor parameters won't be reported as such.
131	/// </summary>
132	InstantiatedWithFixedConstructorSignature = 4,
133
134	/// <summary>Indicates implicit instantiation of a type</summary>
135	InstantiatedNoFixedConstructorSignature = 8
136	}
137
138	/// <summary>
139	/// Specify what is considered used implicitly
140	/// </summary>
141	[Flags]
142	public enum ImplicitUseTargetFlags
143	{
144	Itself = 1,
145	Default = Itself,
146
147	/// <summary>Members of entity marked with attribute are considered used</summary>
148	Members = 2,
149
150	/// <summary>Entity marked with attribute and all its members considered used</summary>
151	WithMembers = Itself \| Members
152	}

HicServices / RDMP / 13318089130

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous