< Summary

Class:Microsoft.Azure.Batch.UtilitiesInternal
Assembly:Microsoft.Azure.Batch
File(s):C:\Git\azure-sdk-for-net\sdk\batch\Microsoft.Azure.Batch\src\UtilitiesInternal.cs
Covered lines:120
Uncovered lines:10
Coverable lines:130
Total lines:556
Line coverage:92.3% (120 of 130)
Covered branches:61
Total branches:68
Branch coverage:89.7% (61 of 68)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
MapEnum(...)-100%100%
MapNullableEnum(...)-100%100%
CertificateVisibilityToList(...)-100%100%
AccessScopeToList(...)-100%100%
ParseCertificateVisibility(...)-100%100%
ParseAccessScope(...)-100%100%
ThrowOnUnbound(...)-100%100%
CreateObjectWithNullCheck(...)-80%75%
ConvertToProtocolCollection(...)-100%100%
ConvertToProtocolArray(...)-100%100%
ConvertEnumCollection(...)-100%100%
ConvertEnumCollection(...)-0%0%
ConvertCollection(...)-100%100%
CollectionToNonThreadSafeCollection(...)-100%100%
CollectionToThreadSafeCollection(...)-100%100%
CollectionToThreadSafeCollectionIModifiable(...)-100%100%
get_OperationForbiddenOnUnboundObjects()-100%100%
get_OperationForbiddenOnBoundObjects()-0%100%
get_MonitorRequiresConsistentHierarchyChain()-0%100%
get_IncorrectTypeReturned()-0%100%
StreamToString(...)-100%100%
EnumerateIfNeededAsync()-83.33%50%
WaitAndUnaggregateException(...)-100%100%
WaitAndUnaggregateException(...)-100%100%
WaitAndUnaggregateException(...)-83.33%50%
WaitAndUnaggregateException(...)-85.71%100%
GetIfChangedOrNull(...)-80%75%
GetTransportObjectIfChanged(...)-100%100%
GetTransportObjectIfChanged(...)-80%75%
ReadNodeFileAsStringAsync()-100%100%

File(s)

C:\Git\azure-sdk-for-net\sdk\batch\Microsoft.Azure.Batch\src\UtilitiesInternal.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License. See License.txt in the project root for license information.
 3
 4namespace Microsoft.Azure.Batch
 5{
 6    using System;
 7    using System.Collections.Generic;
 8    using System.IO;
 9    using System.Linq;
 10    using System.Text;
 11    using System.Threading.Tasks;
 12    using System.Threading;
 13    using Common;
 14    using Utils;
 15
 16    internal static class UtilitiesInternal
 17    {
 18        internal static TTo MapEnum<TFrom, TTo>(TFrom otherEnum)
 19            where TTo : struct
 20            where TFrom : struct
 21        {
 8649522            TTo result = (TTo)Enum.Parse(typeof(TTo), otherEnum.ToString(), ignoreCase: true);
 8649523            return result;
 24        }
 25
 26        internal static TTo? MapNullableEnum<TFrom, TTo>(TFrom? otherEnum)
 27            where TTo : struct
 28            where TFrom : struct
 29        {
 5036230            if (otherEnum == null)
 31            {
 2115032                return null;
 33            }
 34
 2921235            return UtilitiesInternal.MapEnum<TFrom, TTo>(otherEnum.Value);
 36        }
 37
 38        /// <summary>
 39        /// Convert an enum of type CertificateVisibility to a List of Protocol.Models.CertificateVisibility.
 40        /// </summary>
 41        /// <param name='value'>
 42        /// The value to convert.
 43        /// </param>
 44        /// <returns>
 45        /// The enum value to convert into list format.
 46        /// </returns>
 47        internal static IList<Protocol.Models.CertificateVisibility> CertificateVisibilityToList(Common.CertificateVisib
 48        {
 439949            List<Protocol.Models.CertificateVisibility> result = new List<Protocol.Models.CertificateVisibility>();
 439950            if (value.HasValue)
 51            {
 396952                IList<Common.CertificateVisibility> enumValues = new List<Common.CertificateVisibility>(
 396953                    (Common.CertificateVisibility[])Enum.GetValues(typeof(Common.CertificateVisibility)));
 54
 396955                enumValues.Remove(Common.CertificateVisibility.None); //None is an artifact of the OM so skip it
 56
 3175257                foreach (Common.CertificateVisibility enumValue in enumValues)
 58                {
 1190759                    if (value.Value.HasFlag(enumValue))
 60                    {
 565161                        Protocol.Models.CertificateVisibility protoEnumValue = UtilitiesInternal.MapEnum<Common.Certific
 565162                        result.Add(protoEnumValue);
 63                    }
 64                }
 65            }
 66
 439967            return result;
 68        }
 69
 70        /// <summary>
 71        /// Convert an enum of type AccessScope to a List of Protocol.Models.AccessScope.
 72        /// </summary>
 73        /// <param name='value'>
 74        /// The value to convert.
 75        /// </param>
 76        /// <returns>
 77        /// The enum value to convert into list format.
 78        /// </returns>
 79        internal static IList<Protocol.Models.AccessScope> AccessScopeToList(Common.AccessScope value)
 80        {
 68181            List<Protocol.Models.AccessScope> result = new List<Protocol.Models.AccessScope>();
 82
 68183            IList<Common.AccessScope> enumValues = new List<Common.AccessScope>((Common.AccessScope[])Enum.GetValues(typ
 84
 68185            enumValues.Remove(Common.AccessScope.None); //None is an artifact of the OM so skip it
 86
 272487            foreach (Common.AccessScope enumValue in enumValues)
 88            {
 68189                if (value.HasFlag(enumValue))
 90                {
 26191                    Protocol.Models.AccessScope protoEnumValue = UtilitiesInternal.MapEnum<Common.AccessScope, Protocol.
 26192                    result.Add(protoEnumValue);
 93                }
 94            }
 95
 68196            return result;
 97        }
 98
 99        /// <summary>
 100        /// Parse enum values for type CertificateVisibility.
 101        /// </summary>
 102        /// <param name='value'>
 103        /// The value to parse.
 104        /// </param>
 105        /// <returns>
 106        /// The enum value.
 107        /// </returns>
 108        internal static Common.CertificateVisibility? ParseCertificateVisibility(IList<Protocol.Models.CertificateVisibi
 109        {
 10408110            if (value == null)
 111            {
 1277112                return null;
 113            }
 114
 9131115            Common.CertificateVisibility flags = CertificateVisibility.None;
 116
 71634117            foreach (Protocol.Models.CertificateVisibility visibility in value)
 118            {
 26686119                Common.CertificateVisibility convertedEnum = UtilitiesInternal.MapEnum<Protocol.Models.CertificateVisibi
 120
 26686121                flags |= convertedEnum;
 122            }
 123
 9131124            return flags;
 125        }
 126
 127
 128        /// <summary>
 129        /// Parse enum values for type AccessScope.
 130        /// </summary>
 131        /// <param name='value'>
 132        /// The value to parse.
 133        /// </param>
 134        /// <returns>
 135        /// The enum value.
 136        /// </returns>
 137        internal static Common.AccessScope ParseAccessScope(IList<Protocol.Models.AccessScope> value)
 138        {
 1986139            if (value == null)
 140            {
 458141                return Common.AccessScope.None;
 142            }
 143
 1528144            Common.AccessScope flags = AccessScope.None;
 145
 11440146            foreach (Protocol.Models.AccessScope visibility in value)
 147            {
 4192148                Common.AccessScope convertedEnum = UtilitiesInternal.MapEnum<Protocol.Models.AccessScope, Common.AccessS
 149
 4192150                flags |= convertedEnum;
 151            }
 152
 1528153            return flags;
 154        }
 155
 156
 157        internal static void ThrowOnUnbound(BindingState bindingState)
 158        {
 37159            if (BindingState.Unbound == bindingState)
 160            {
 4161                throw OperationForbiddenOnUnboundObjects;
 162            }
 33163        }
 164
 165        internal static TWrappedItem CreateObjectWithNullCheck<TItem, TWrappedItem>(TItem item, Func<TItem, TWrappedItem
 166            where TItem : class
 167            where TWrappedItem : class
 168        {
 159030169            if (item == null)
 170            {
 76782171                if (nullFactory != null)
 172                {
 0173                    return nullFactory();
 174                }
 175                else
 176                {
 76782177                    return null;
 178                }
 179            }
 180            else
 181            {
 82248182                return factory(item);
 183            }
 184        }
 185
 186        #region Collection conversions
 187
 188        /// <summary>
 189        /// Converts a collection of object model items into a corresponding collection of transport layer items.
 190        /// If the <paramref name="items"/> collection is null, null is returned.
 191        /// </summary>
 192        /// <returns>
 193        /// A collection of type <typeparam name="T"/> generated by calling
 194        /// <see cref="ITransportObjectProvider{T}.GetTransportObject"/> on each element of the input collection.
 195        /// </returns>
 196        internal static IList<T> ConvertToProtocolCollection<T>(IEnumerable<ITransportObjectProvider<T>> items)
 197        {
 10762198            if (null == items)
 199            {
 6593200                return null;
 201            }
 202
 4169203            List<T> protocolItems = new List<T>();
 204
 45658205            foreach (ITransportObjectProvider<T> item in items)
 206            {
 18660207                T protocolItem = item.GetTransportObject();
 208
 209                // add the protocol object to the return collection
 18660210                protocolItems.Add(protocolItem);
 211            }
 212
 4169213            return protocolItems;
 214        }
 215
 216        /// <summary>
 217        /// Converts a collection of object model items into a corresponding array of transport layer items.
 218        /// If the <paramref name="items"/> collection is null, null is returned.
 219        /// </summary>
 220        /// <returns>
 221        /// A collection of type <typeparam name="T"/> generated by calling
 222        /// <see cref="ITransportObjectProvider{T}.GetTransportObject"/> on each element of the input collection.
 223        /// </returns>
 224        internal static T[] ConvertToProtocolArray<T>(IEnumerable<ITransportObjectProvider<T>> items)
 225        {
 6226            IEnumerable<T> protocolCollection = ConvertToProtocolCollection(items);
 227
 6228            if (protocolCollection != null)
 229            {
 4230                return protocolCollection.ToArray();
 231            }
 232            else
 233            {
 2234                return null;
 235            }
 236        }
 237
 238        internal static IList<TTo> ConvertEnumCollection<TFrom, TTo>(IEnumerable<TFrom> items)
 239            where TFrom : struct
 240            where TTo : struct
 241        {
 518242            return items?.Select(MapEnum<TFrom, TTo>).ToList();
 243        }
 244
 245        internal static IList<TTo?> ConvertEnumCollection<TFrom, TTo>(IEnumerable<TFrom?> items)
 246            where TFrom : struct
 247            where TTo : struct
 248        {
 0249            return items?.Select(MapNullableEnum<TFrom, TTo>).ToList();
 250        }
 251
 252        private static TList ConvertCollection<TIn, TOut, TList>(
 253            IEnumerable<TIn> items,
 254            Func<TIn, TOut> objectCreationFunc,
 255            Func<IEnumerable<TOut>, TList> listCreationFunc)
 256            where TList : class, IList<TOut>
 257            where TIn : class
 258            where TOut : class
 259        {
 39834260            if (null == items)
 261            {
 20166262                return null;
 263            }
 264
 108362265            TList result = listCreationFunc(items.Select(item => item == null ? null : objectCreationFunc(item)));
 266
 19668267            return result;
 268        }
 269
 270        /// <summary>
 271        /// Applies the <paramref name="objectCreationFunc"/> to each item in <paramref name="items"/> and returns a non
 272        /// </summary>
 273        /// <typeparam name="TIn">The type of the input collection.</typeparam>
 274        /// <typeparam name="TOut">The type of the output collection.</typeparam>
 275        /// <param name="items">The collection to convert.</param>
 276        /// <param name="objectCreationFunc">The function used to created each <typeparamref name="TOut"/> type object.<
 277        /// <returns>A non-threadsafe collection containing the results of the conversion, or null if <paramref name="it
 278        internal static List<TOut> CollectionToNonThreadSafeCollection<TIn, TOut>(
 279            IEnumerable<TIn> items,
 280            Func<TIn, TOut> objectCreationFunc)
 281            where TIn : class
 282            where TOut : class
 283        {
 13322284            List<TOut> result = UtilitiesInternal.ConvertCollection(
 13322285                items,
 13322286                objectCreationFunc,
 19922287                (convertedItemsEnumerable) => new List<TOut>(convertedItemsEnumerable));
 288
 13322289            return result;
 290        }
 291
 292        /// <summary>
 293        /// Applies the <paramref name="objectCreationFunc"/> to each item in <paramref name="items"/> and returns a non
 294        /// </summary>
 295        /// <typeparam name="TIn">The type of the input collection.</typeparam>
 296        /// <typeparam name="TOut">The type of the output collection.</typeparam>
 297        /// <param name="items">The collection to convert.</param>
 298        /// <param name="objectCreationFunc">The function used to created each <typeparamref name="TOut"/> type object.<
 299        /// <returns>A non-threadsafe collection containing the results of the conversion, or null if <paramref name="it
 300        internal static IList<TOut> CollectionToThreadSafeCollection<TIn, TOut>(
 301            IEnumerable<TIn> items,
 302            Func<TIn, TOut> objectCreationFunc)
 303            where TIn : class
 304            where TOut : class
 305        {
 1830306            ConcurrentChangeTrackedList<TOut> result = UtilitiesInternal.ConvertCollection(
 1830307                items,
 1830308                objectCreationFunc,
 2723309                (convertedItemsEnumerable) => new ConcurrentChangeTrackedList<TOut>(convertedItemsEnumerable));
 310
 1830311            return result;
 312        }
 313
 314        /// <summary>
 315        /// Applies the <paramref name="objectCreationFunc"/> to each item in <paramref name="items"/> and returns a thr
 316        /// </summary>
 317        /// <typeparam name="TIn">The type of the input collection.</typeparam>
 318        /// <typeparam name="TOut">The type of the output collection.</typeparam>
 319        /// <param name="items">The collection to convert.</param>
 320        /// <param name="objectCreationFunc">The function used to created each <typeparamref name="TOut"/> type object.<
 321        /// <returns>A threadsafe collection containing the results of the conversion, or null if <paramref name="items"
 322        internal static ConcurrentChangeTrackedModifiableList<TOut> CollectionToThreadSafeCollectionIModifiable<TIn, TOu
 323            IEnumerable<TIn> items,
 324            Func<TIn, TOut> objectCreationFunc)
 325            where TIn : class
 326            where TOut : class, IPropertyMetadata
 327        {
 24682328            ConcurrentChangeTrackedModifiableList<TOut> result = UtilitiesInternal.ConvertCollection(
 24682329                items,
 24682330                objectCreationFunc,
 36857331                (convertedItemsEnumerable) => new ConcurrentChangeTrackedModifiableList<TOut>(convertedItemsEnumerable))
 332
 24682333            return result;
 334        }
 335
 336        #endregion
 337
 338        internal static Exception OperationForbiddenOnUnboundObjects
 339        {
 340            get
 341            {
 4342                return new InvalidOperationException(BatchErrorMessages.OperationForbiddenOnUnboundObjects);
 343            }
 344        }
 345
 346        internal static Exception OperationForbiddenOnBoundObjects
 347        {
 348            get
 349            {
 0350                return new InvalidOperationException(BatchErrorMessages.OperationForbiddenOnBoundObjects);
 351            }
 352        }
 353
 354        internal static Exception MonitorRequiresConsistentHierarchyChain
 355        {
 356            get
 357            {
 0358                return new InvalidOperationException(BatchErrorMessages.MonitorInstancesMustHaveSameServerSideParent);
 359            }
 360        }
 361
 362        internal static Exception IncorrectTypeReturned
 363        {
 364            get
 365            {
 0366                return new InvalidOperationException(BatchErrorMessages.IncorrectTypeReturned);
 367            }
 368        }
 369
 370        /// <summary>
 371        /// Reads entire Stream into a string.  When null encoding is provided, UTF8 is used.
 372        /// </summary>
 373        /// <param name="s"></param>
 374        /// <param name="encoding"></param>
 375        /// <returns></returns>
 376        internal static string StreamToString(Stream s, Encoding encoding)
 377        {
 6378            if (null == encoding)
 379            {
 2380                encoding = Encoding.UTF8;
 381            }
 382
 383            //Avoid disposing of the underlying stream -- the streams lifetime is not owned by this method
 384            //and disposing the reader will dispose the underlying stream.
 385
 386            //Note: detectEncodingFromByteOrderMarks default is true, and bufferSize default is 1024, we have to pass th
 387            //get access to the leaveOpen parameter.
 6388            using (StreamReader reader = new StreamReader(s, encoding, detectEncodingFromByteOrderMarks: true, bufferSiz
 389            {
 6390                string txt = reader.ReadToEnd();
 391
 6392                return txt;
 393            }
 6394        }
 395
 396        /// <summary>
 397        /// Enumerates an enumerable asyncronously if required.  If the enumerable is of type IPagedCollection(T) then
 398        /// ToListAsync is called on it.  Otherwise the enumerable is returned as is.
 399        /// </summary>
 400        internal static async Task<IEnumerable<T>> EnumerateIfNeededAsync<T>(IEnumerable<T> enumerable, CancellationToke
 401        {
 402            IEnumerable<T> result;
 403
 9404            IPagedEnumerable<T> pagedEnumerable = enumerable as IPagedEnumerable<T>;
 405
 9406            if (pagedEnumerable != null)
 407            {
 0408                result = await pagedEnumerable.ToListAsync(cancellationToken).ConfigureAwait(false);
 409            }
 410            else
 411            {
 9412                result = enumerable;
 413            }
 414
 9415            return result;
 9416        }
 417
 418        internal static void WaitAndUnaggregateException(this Task task)
 419        {
 74420            task.GetAwaiter().GetResult();
 68421        }
 422
 423        internal static T WaitAndUnaggregateException<T>(this Task<T> task)
 424        {
 57425            return task.GetAwaiter().GetResult();
 426        }
 427
 428        internal static void WaitAndUnaggregateException(this Task task, IEnumerable<BatchClientBehavior> rootBehaviors,
 429        {
 34430            BehaviorManager bhMgr = new BehaviorManager(rootBehaviors, additionalBehaviors);
 34431            SynchronousMethodExceptionBehavior exceptionBehavior = bhMgr.GetBehaviors<SynchronousMethodExceptionBehavior
 34432            if (exceptionBehavior != null)
 433            {
 0434                exceptionBehavior.Wait(task);
 435            }
 436            else
 437            {
 34438                task.WaitAndUnaggregateException();
 439            }
 28440        }
 441
 442        internal static T WaitAndUnaggregateException<T>(this Task<T> task, IEnumerable<BatchClientBehavior> rootBehavio
 443        {
 41444            BehaviorManager bhMgr = new BehaviorManager(rootBehaviors, additionalBehaviors);
 41445            SynchronousMethodExceptionBehavior exceptionBehavior = bhMgr.GetBehaviors<SynchronousMethodExceptionBehavior
 446            T result;
 41447            if (exceptionBehavior != null)
 448            {
 2449                exceptionBehavior.Wait(task);
 0450                result = task.Result;
 451            }
 452            else
 453            {
 39454                result = task.WaitAndUnaggregateException();
 455            }
 456
 37457            return result;
 458        }
 459
 460        /// <summary>
 461        /// Gets the object if the property has been changed, otherwise returns null.
 462        /// </summary>
 463        /// <exception cref="InvalidOperationException">When the property was changed to null, since the patch REST verb
 464        internal static T? GetIfChangedOrNull<T>(this PropertyAccessor<T?> property)
 465            where T : struct
 466        {
 6467            if (property.HasBeenModified)
 468            {
 1469                if (property.Value == null)
 470                {
 0471                    throw new InvalidOperationException(BatchErrorMessages.CannotPatchNullValue);
 472                }
 1473                return property.Value;
 474            }
 475            else
 476            {
 5477                return null;
 478            }
 479        }
 480
 481        /// <summary>
 482        /// Gets the transport object if the property has been changed, otherwise returns null.
 483        /// </summary>
 484        /// <exception cref="InvalidOperationException">When the property was changed to null, since the patch REST verb
 485        internal static TProtocol GetTransportObjectIfChanged<TObjectModel, TProtocol>(this PropertyAccessor<TObjectMode
 486            where TObjectModel : class, ITransportObjectProvider<TProtocol>
 487            where TProtocol : class
 488        {
 31489            if (property.HasBeenModified)
 490            {
 9491                if (property.Value == null)
 492                {
 3493                    throw new InvalidOperationException(BatchErrorMessages.CannotPatchNullValue);
 494                }
 12495                return CreateObjectWithNullCheck(property.Value, item => item.GetTransportObject());
 496            }
 497            else
 498            {
 22499                return null;
 500            }
 501        }
 502
 503        /// <summary>
 504        /// Gets the transport object if the property has been changed, otherwise returns null.
 505        /// </summary>
 506        /// <exception cref="InvalidOperationException">When the property was changed to null, since the patch REST verb
 507        internal static TProtocol[] GetTransportObjectIfChanged<TObjectModel, TProtocol>(this PropertyAccessor<IList<TOb
 508            where TObjectModel : class, ITransportObjectProvider<TProtocol>
 509            where TProtocol : class
 510        {
 30511            if (property.HasBeenModified)
 512            {
 3513                if (property.Value == null)
 514                {
 0515                    throw new InvalidOperationException(BatchErrorMessages.CannotPatchNullValue);
 516                }
 3517                return ConvertToProtocolArray(property.Value);
 518            }
 519            else
 520            {
 27521                return null;
 522            }
 523        }
 524
 525        /// <summary>
 526        /// Begins asynchronous call to return the contents of the file as a string.
 527        /// </summary>
 528        /// <param name="copyStreamFunc">The stream copy function.</param>
 529        /// <param name="encoding">The encoding used to interpret the file data. If no value or null is specified, UTF8 
 530        /// <param name="byteRange">The file byte range to retrieve. If null, the entire file is retrieved.</param>
 531        /// <param name="additionalBehaviors">A collection of BatchClientBehavior instances that are applied after the C
 532        /// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynch
 533        /// <returns>A <see cref="System.Threading.Tasks.Task"/> object that represents the asynchronous operation.</ret
 534        internal static async Task<string> ReadNodeFileAsStringAsync(
 535            Func<Stream, GetFileRequestByteRange, IEnumerable<BatchClientBehavior>, CancellationToken, Task> copyStreamF
 536            Encoding encoding,
 537            GetFileRequestByteRange byteRange,
 538            IEnumerable<BatchClientBehavior> additionalBehaviors,
 539            CancellationToken cancellationToken)
 540        {
 4541            using (Stream streamToUse = new MemoryStream())
 542            {
 543                // get the data
 4544                Task asyncTask = copyStreamFunc(streamToUse, byteRange, additionalBehaviors, cancellationToken);
 545
 546                // wait for completion
 4547                await asyncTask.ConfigureAwait(continueOnCapturedContext: false);
 548
 2549                streamToUse.Seek(0, SeekOrigin.Begin); //We just wrote to this stream, have to seek to the beginning
 550                // convert to string
 2551                return StreamToString(streamToUse, encoding);
 552            }
 2553        }
 554    }
 555
 556}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:47:13 PM
GitHub | www.palmmedia.de

Methods/Properties

MapEnum(...)
MapNullableEnum(...)
CertificateVisibilityToList(...)
AccessScopeToList(...)
ParseCertificateVisibility(...)
ParseAccessScope(...)
ThrowOnUnbound(...)
CreateObjectWithNullCheck(...)
ConvertToProtocolCollection(...)
ConvertToProtocolArray(...)
ConvertEnumCollection(...)
ConvertEnumCollection(...)
ConvertCollection(...)
CollectionToNonThreadSafeCollection(...)
CollectionToThreadSafeCollection(...)
CollectionToThreadSafeCollectionIModifiable(...)
get_OperationForbiddenOnUnboundObjects()
get_OperationForbiddenOnBoundObjects()
get_MonitorRequiresConsistentHierarchyChain()
get_IncorrectTypeReturned()
StreamToString(...)
EnumerateIfNeededAsync()
WaitAndUnaggregateException(...)
WaitAndUnaggregateException(...)
WaitAndUnaggregateException(...)
WaitAndUnaggregateException(...)
GetIfChangedOrNull(...)
GetTransportObjectIfChanged(...)
GetTransportObjectIfChanged(...)
ReadNodeFileAsStringAsync()