< Summary

Information
Class: DotnetFuzzing.Fuzzers.Base64UrlFuzzer
Assembly: DotnetFuzzing
File(s): D:\runner\runtime\src\libraries\Fuzzing\DotnetFuzzing\Fuzzers\Base64UrlFuzzer.cs
Line coverage
93%
Covered lines: 88
Uncovered lines: 6
Coverable lines: 94
Total lines: 136
Line coverage: 93.6%
Branch coverage
83%
Covered branches: 5
Total branches: 6
Branch coverage: 83.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
FuzzTarget(...)83.33%6695.65%

File(s)

D:\runner\runtime\src\libraries\Fuzzing\DotnetFuzzing\Fuzzers\Base64UrlFuzzer.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System.Buffers;
 5using System.Buffers.Text;
 6using System.Formats.Asn1;
 7using System.Reflection;
 8
 9namespace DotnetFuzzing.Fuzzers
 10{
 11    internal sealed class Base64UrlFuzzer : IFuzzer
 12    {
 013        public string[] TargetAssemblies => [];
 14
 015        public string[] TargetCoreLibPrefixes => ["System.Buffers.Text"];
 16
 17        public void FuzzTarget(ReadOnlySpan<byte> bytes)
 143518        {
 143519            int encodedLength = Base64Url.GetEncodedLength(bytes.Length);
 143520            int maxDecodedLength = Base64Url.GetMaxDecodedLength(encodedLength);
 21
 143522            using PooledBoundedMemory<byte> inputPoisoned = PooledBoundedMemory<byte>.Rent(bytes, PoisonPagePlacement.Af
 143523            using PooledBoundedMemory<char> destPoisoned = PooledBoundedMemory<char>.Rent(encodedLength, PoisonPagePlace
 143524            using PooledBoundedMemory<byte> decoderDestPoisoned = PooledBoundedMemory<byte>.Rent(maxDecodedLength, Poiso
 25
 143526            Span<byte> input = inputPoisoned.Span;
 143527            Span<char> encoderDest = destPoisoned.Span;
 143528            Span<byte> decoderDest = decoderDestPoisoned.Span;
 29
 143530            { // IsFinalBlock = true
 143531                OperationStatus status = Base64Url.EncodeToChars(input, encoderDest, out int bytesConsumed, out int byte
 32
 143533                Assert.Equal(OperationStatus.Done, status);
 143534                Assert.Equal(bytes.Length, bytesConsumed);
 143535                Assert.Equal(true, encodedLength == bytesEncoded);
 36
 143537                string encodedString = Base64Url.EncodeToString(input);
 143538                Assert.Equal(encodedString, new string(encoderDest));
 39
 143540                status = Base64Url.DecodeFromChars(encoderDest, decoderDest, out int bytesRead, out int bytesDecoded);
 41
 143542                Assert.Equal(OperationStatus.Done, status);
 143543                Assert.Equal(bytes.Length, bytesDecoded);
 143544                Assert.Equal(bytesEncoded, bytesRead);
 143545                Assert.SequenceEqual(bytes, decoderDest.Slice(0, bytesDecoded));
 143546            }
 47
 143548            { // IsFinalBlock = false
 143549                encoderDest.Clear();
 143550                decoderDest.Clear();
 143551                OperationStatus status = Base64Url.EncodeToChars(input, encoderDest, out int bytesConsumed, out int byte
 143552                Span<char> decodeInput = encoderDest.Slice(0, bytesEncoded);
 53
 143554                if (bytes.Length % 3 == 0)
 54955                {
 54956                    Assert.Equal(OperationStatus.Done, status);
 54957                    Assert.Equal(bytes.Length, bytesConsumed);
 54958                    Assert.Equal(true, encodedLength == bytesEncoded);
 59
 54960                    status = Base64Url.DecodeFromChars(decodeInput, decoderDest, out int bytesRead, out int bytesDecoded
 61
 54962                    Assert.Equal(OperationStatus.Done, status);
 54963                    Assert.Equal(bytes.Length, bytesDecoded);
 54964                    Assert.Equal(bytesEncoded, bytesRead);
 54965                    Assert.SequenceEqual(bytes, decoderDest.Slice(0, bytesDecoded));
 54966                }
 67                else
 88668                {
 88669                    Assert.Equal(OperationStatus.NeedMoreData, status);
 88670                    Assert.Equal(true, input.Length / 3 * 4 == bytesEncoded);
 71
 88672                    status = Base64Url.DecodeFromChars(decodeInput, decoderDest, out int bytesRead, out int bytesDecoded
 73
 88674                    if (decodeInput.Length % 4 == 0)
 88675                    {
 88676                        Assert.Equal(OperationStatus.Done, status);
 88677                        Assert.Equal(bytesConsumed, bytesDecoded);
 88678                        Assert.Equal(bytesEncoded, bytesRead);
 88679                    }
 80                    else
 081                    {
 082                        Assert.Equal(OperationStatus.NeedMoreData, status);
 083                    }
 84
 88685                    Assert.SequenceEqual(bytes.Slice(0, bytesDecoded), decoderDest.Slice(0, bytesDecoded));
 88686                }
 143587            }
 88
 143589            { // Encode / decode in place
 143590                using PooledBoundedMemory<byte> destPoisoned2 = PooledBoundedMemory<byte>.Rent(encodedLength, PoisonPage
 143591                Span<byte> tryEncode = destPoisoned2.Span;
 143592                input.CopyTo(tryEncode);
 93
 143594                Assert.Equal(true, Base64Url.TryEncodeToUtf8InPlace(tryEncode, input.Length, out int bytesEncoded));
 143595                Assert.Equal(encodedLength, bytesEncoded);
 96
 143597                int bytesDecoded = Base64Url.DecodeFromUtf8InPlace(tryEncode);
 98
 143599                Assert.Equal(bytes.Length, bytesDecoded);
 1435100                Assert.SequenceEqual(bytes, tryEncode.Slice(0, bytesDecoded));
 1435101            }
 102
 1435103            { // Decode the random input directly, Assert IsValid result matches with decoded result
 1435104                decoderDest.Clear();
 1435105                if (Base64Url.IsValid(input, out int decodedLength))
 678106                {
 678107                    maxDecodedLength = Base64Url.GetMaxDecodedLength(input.Length);
 678108                    OperationStatus status = Base64Url.DecodeFromUtf8(input, decoderDest, out int bytesRead, out int byt
 678109                    Assert.Equal(OperationStatus.Done, status);
 678110                    Assert.Equal(input.Length, bytesRead);
 678111                    Assert.Equal(decodedLength, bytesDecoded);
 678112                    Assert.Equal(true, maxDecodedLength >= bytesDecoded);
 113
 678114                    Span<byte> tryDecode = new byte[maxDecodedLength];
 678115                    Assert.Equal(true, Base64Url.TryDecodeFromUtf8(input, tryDecode, out bytesDecoded));
 678116                    Assert.Equal(decodedLength, bytesDecoded);
 678117                    Assert.SequenceEqual<byte>(tryDecode.Slice(0, bytesDecoded), decoderDest.Slice(0, bytesDecoded));
 118
 678119                    int decoded = Base64Url.DecodeFromUtf8InPlace(input);
 678120                    Assert.Equal(OperationStatus.Done, status);
 678121                    Assert.Equal(bytesDecoded, decoded);
 678122                    Assert.SequenceEqual<byte>(input.Slice(0, decoded), decoderDest.Slice(0, bytesDecoded));
 678123                }
 124                else
 757125                {
 757126                    Assert.Equal(OperationStatus.InvalidData, Base64Url.DecodeFromUtf8(input, decoderDest, out int _, ou
 127                    try
 757128                    {
 757129                        Assert.Equal(0, Base64Url.DecodeFromUtf8InPlace(input));
 0130                    }
 2271131                    catch (FormatException) { /* DecodeFromUtf8InPlace would throw FormatException for InvalidData*/ }
 757132                }
 1435133            }
 2870134        }
 135    }
 136}
Generated by: ReportGenerator 5.5.12.0
10/31/2026 - 12:15:09 PM
GitHub | reportgenerator.io

Methods/Properties

TargetAssemblies()
TargetCoreLibPrefixes()
FuzzTarget(System.ReadOnlySpan`1<System.Byte>)