dotnet/tests/CommunityToolkit.HighPerformance.UnitTests/Test_NullableReadOnlyRef{T}.cs at 77e0435df0e34ebdf6904fe3c656d0c68f4c629b · CommunityToolkit/dotnet · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

#if NET8_0_OR_GREATER

using System;
using System.Runtime.CompilerServices;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace CommunityToolkit.HighPerformance.UnitTests;

[TestClass]
public class Test_NullableReadOnlyRefOfT
{
    [TestMethod]
    public void Test_NullableReadOnlyRefOfT_CreateNullableReadOnlyRefOfT_Ok()
    {
        int value = 1;
        NullableReadOnlyRef<int> reference = new(value);

        Assert.IsTrue(reference.HasValue);
        Assert.IsTrue(Unsafe.AreSame(ref value, ref Unsafe.AsRef(in reference.Value)));
    }

    [TestMethod]
    public void Test_NullableReadOnlyRefOfT_CreateNullableReadOnlyRefOfT_Null()
    {
        Assert.IsFalse(default(NullableReadOnlyRef<int>).HasValue);
        Assert.IsFalse(NullableReadOnlyRef<int>.Null.HasValue);

        Assert.IsFalse(default(NullableReadOnlyRef<string>).HasValue);
        Assert.IsFalse(NullableReadOnlyRef<string>.Null.HasValue);
    }

    [TestMethod]
    [ExpectedException(typeof(InvalidOperationException))]
    public void Test_NullableReadOnlyRefOfT_CreateNullableReadOnlyRefOfT_Null_Exception()
    {
        NullableReadOnlyRef<int> reference = default;

        _ = reference.Value;
    }

    [TestMethod]
    public void Test_NullableReadOnlyRefOfT_CreateNullableReadOnlyRefOfT_ImplicitRefCast()
    {
        int value = 42;
        Ref<int> reference = new(ref value);
        NullableReadOnlyRef<int> nullableRef = reference;

        Assert.IsTrue(nullableRef.HasValue);
        Assert.IsTrue(Unsafe.AreSame(ref reference.Value, ref Unsafe.AsRef(in nullableRef.Value)));
    }

    [TestMethod]
    public void Test_NullableReadOnlyRefOfT_CreateNullableReadOnlyRefOfT_ImplicitReadOnlyRefCast()
    {
        int value = 42;
        ReadOnlyRef<int> reference = new(value);
        NullableReadOnlyRef<int> nullableRef = reference;

        Assert.IsTrue(nullableRef.HasValue);
        Assert.IsTrue(Unsafe.AreSame(ref Unsafe.AsRef(in reference.Value), ref Unsafe.AsRef(in nullableRef.Value)));
    }

    [TestMethod]
    public void Test_NullableReadOnlyRefOfT_CreateNullableReadOnlyRefOfT_ImplicitNullableRefCast()
    {
        int value = 42;
        NullableRef<int> reference = new(ref value);
        NullableReadOnlyRef<int> nullableRef = reference;

        Assert.IsTrue(nullableRef.HasValue);
        Assert.IsTrue(Unsafe.AreSame(ref reference.Value, ref Unsafe.AsRef(in nullableRef.Value)));
    }

    [TestMethod]
    public void Test_NullableReadOnlyRefOfT_CreateNullableReadOnlyRefOfT_ExplicitCastOfT()
    {
        int value = 42;
        NullableRef<int> reference = new(ref value);

        Assert.AreEqual(value, (int)reference);
    }

    [TestMethod]
    [ExpectedException(typeof(InvalidOperationException))]
    public void Test_NullableReadOnlyRefOfT_CreateNullableReadOnlyRefOfT_ExplicitCastOfT_Exception()
    {
        NullableRef<int> invalid = default;

        _ = (int)invalid;
    }
}

#endif