< Summary - CoreWCF Coverage — PR #1766

Information
Class: CoreWCF.Channels.BufferedMessageData
Assembly: CoreWCF.Primitives
File(s): /home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Channels/BufferedMessageData.cs
Line coverage
84%
Covered lines: 58
Uncovered lines: 11
Coverable lines: 69
Total lines: 200
Line coverage: 84%
Branch coverage
72%
Covered branches: 13
Total branches: 18
Branch coverage: 72.2%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.ctor(...)100%11100%
EnableMultipleUsers()100%11100%
Close()25%4442.85%
DoClose()100%22100%
DoReturnMessageState(...)50%2250%
DoReturnXmlReader(...)100%11100%
DoTakeMessageState()100%22100%
DoTakeXmlReader()100%11100%
GetMessageReader()100%22100%
OnXmlReaderClosed(...)100%22100%
OnClosed()100%110%
TakeMessageState()100%22100%
Open()100%11100%
Open(...)100%11100%
ReturnMessageState(...)50%2250%

File(s)

/home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Channels/BufferedMessageData.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;
 5using System.Xml;
 6using CoreWCF.Runtime;
 7
 8namespace CoreWCF.Channels
 9{
 10    internal abstract class BufferedMessageData : IBufferedMessageData
 11    {
 12        private ArraySegment<byte> _buffer;
 13        private int _refCount;
 14        private int _outstandingReaders;
 15        private bool _multipleUsers;
 16        private RecycledMessageState _messageState;
 17        private readonly SynchronizedPool<RecycledMessageState> _messageStatePool;
 18
 63219        public BufferedMessageData(SynchronizedPool<RecycledMessageState> messageStatePool)
 20        {
 63221            _messageStatePool = messageStatePool;
 63222        }
 23
 24        public ArraySegment<byte> Buffer
 25        {
 230126            get { return _buffer; }
 27        }
 28
 200729        public BufferManager BufferManager { get; private set; }
 30
 31        public virtual XmlDictionaryReaderQuotas Quotas
 32        {
 033            get { return XmlDictionaryReaderQuotas.Max; }
 34        }
 35
 36        public abstract MessageEncoder MessageEncoder { get; }
 37
 38        private object ThisLock
 39        {
 267040            get { return this; }
 41        }
 42
 43        public void EnableMultipleUsers()
 44        {
 17845            _multipleUsers = true;
 17846        }
 47
 48        public void Close()
 49        {
 61750            if (_multipleUsers)
 51            {
 052                lock (ThisLock)
 53                {
 054                    if (--_refCount == 0)
 55                    {
 056                        DoClose();
 57                    }
 058                }
 59            }
 60            else
 61            {
 61762                DoClose();
 63            }
 61764        }
 65
 66        private void DoClose()
 67        {
 61768            BufferManager.ReturnBuffer(_buffer.Array);
 61769            if (_outstandingReaders == 0)
 70            {
 51671                BufferManager = null;
 51672                _buffer = new ArraySegment<byte>();
 51673                OnClosed();
 74            }
 61775        }
 76
 77        public void DoReturnMessageState(RecycledMessageState messageState)
 78        {
 61779            if (_messageState == null)
 80            {
 61781                _messageState = messageState;
 82            }
 83            else
 84            {
 085                _messageStatePool.Return(messageState);
 86            }
 087        }
 88
 89        private void DoReturnXmlReader(XmlDictionaryReader reader)
 90        {
 186791            ReturnXmlReader(reader);
 186792            _outstandingReaders--;
 186793        }
 94
 95        public RecycledMessageState DoTakeMessageState()
 96        {
 105297            RecycledMessageState messageState = _messageState;
 105298            if (messageState != null)
 99            {
 242100                _messageState = null;
 242101                return messageState;
 102            }
 103            else
 104            {
 810105                return _messageStatePool.Take();
 106            }
 107        }
 108
 109        private XmlDictionaryReader DoTakeXmlReader()
 110        {
 2301111            XmlDictionaryReader reader = TakeXmlReader();
 2301112            _outstandingReaders++;
 2301113            return reader;
 114        }
 115
 116        public XmlDictionaryReader GetMessageReader()
 117        {
 2301118            if (_multipleUsers)
 119            {
 1068120                lock (ThisLock)
 121                {
 1068122                    return DoTakeXmlReader();
 123                }
 124            }
 125            else
 126            {
 1233127                return DoTakeXmlReader();
 128            }
 1068129        }
 130
 131        public void OnXmlReaderClosed(XmlDictionaryReader reader)
 132        {
 1867133            if (_multipleUsers)
 134            {
 1068135                lock (ThisLock)
 136                {
 1068137                    DoReturnXmlReader(reader);
 1068138                }
 139            }
 140            else
 141            {
 799142                DoReturnXmlReader(reader);
 143            }
 1867144        }
 145
 146        protected virtual void OnClosed()
 147        {
 0148        }
 149
 150        public RecycledMessageState TakeMessageState()
 151        {
 1052152            if (_multipleUsers)
 153            {
 178154                lock (ThisLock)
 155                {
 178156                    return DoTakeMessageState();
 157                }
 158            }
 159            else
 160            {
 874161                return DoTakeMessageState();
 162            }
 178163        }
 164
 165        protected abstract XmlDictionaryReader TakeXmlReader();
 166
 167        public void Open()
 168        {
 356169            lock (ThisLock)
 170            {
 356171                _refCount++;
 356172            }
 356173        }
 174
 175        public void Open(ArraySegment<byte> buffer, BufferManager bufferManager)
 176        {
 874177            _refCount = 1;
 874178            BufferManager = bufferManager;
 874179            _buffer = buffer;
 874180            _multipleUsers = false;
 874181        }
 182
 183        protected abstract void ReturnXmlReader(XmlDictionaryReader xmlReader);
 184
 185        public void ReturnMessageState(RecycledMessageState messageState)
 186        {
 617187            if (_multipleUsers)
 188            {
 0189                lock (ThisLock)
 190                {
 0191                    DoReturnMessageState(messageState);
 0192                }
 193            }
 194            else
 195            {
 617196                DoReturnMessageState(messageState);
 197            }
 617198        }
 199    }
 200}
Generated by: ReportGenerator 5.5.11.0
08/09/2026 - 10:15:49
GitHub | reportgenerator.io

Methods/Properties

.ctor(CoreWCF.Runtime.SynchronizedPool`1<CoreWCF.Channels.RecycledMessageState>)
Buffer()
BufferManager()
Quotas()
ThisLock()
EnableMultipleUsers()
Close()
DoClose()
DoReturnMessageState(CoreWCF.Channels.RecycledMessageState)
DoReturnXmlReader(System.Xml.XmlDictionaryReader)
DoTakeMessageState()
DoTakeXmlReader()
GetMessageReader()
OnXmlReaderClosed(System.Xml.XmlDictionaryReader)
OnClosed()
TakeMessageState()
Open()
Open(System.ArraySegment`1<System.Byte>,CoreWCF.Channels.BufferManager)
ReturnMessageState(CoreWCF.Channels.RecycledMessageState)