How to use ByteDataSource class of NUnit.Framework package

...117        /// Construct a set of bytes within a specified range118        /// </summary>119        public RandomAttribute(byte min, byte max, int count)120        {121            _source = new ByteDataSource(min, max, count);122        }123        /// <summary>124        /// Construct a set of sbytes within a specified range125        /// </summary>126        //[CLSCompliant(false)]127        public RandomAttribute(sbyte min, sbyte max, int count)128        {129            _source = new SByteDataSource(min, max, count);130        }131        #endregion132        #region IParameterDataSource Interface133        /// <summary>134        /// Get the collection of _values to be used as arguments.135        /// </summary>136        public IEnumerable GetData(IParameterInfo parameter)137        {138            // Since a separate Randomizer is used for each parameter,139            // we can't fill in the data in the constructor of the140            // attribute. Only now, when GetData is called, do we have141            // sufficient information to create the values in a 142            // repeatable manner.143            Type parmType = parameter.ParameterType;144            if (_source == null)145            {146                if (parmType == typeof(int))147                    _source = new IntDataSource(_count);148                else if (parmType == typeof(uint))149                    _source = new UIntDataSource(_count);150                else if (parmType == typeof(long))151                    _source = new LongDataSource(_count);152                else if (parmType == typeof(ulong))153                    _source = new ULongDataSource(_count);154                else if (parmType == typeof(short))155                    _source = new ShortDataSource(_count);156                else if (parmType == typeof(ushort))157                    _source = new UShortDataSource(_count);158                else if (parmType == typeof(double))159                    _source = new DoubleDataSource(_count);160                else if (parmType == typeof(float))161                    _source = new FloatDataSource(_count);162                else if (parmType == typeof(byte))163                    _source = new ByteDataSource(_count);164                else if (parmType == typeof(sbyte))165                    _source = new SByteDataSource(_count);166                else if (parmType == typeof(decimal))167                    _source = new DecimalDataSource(_count);168                else if (parmType.GetTypeInfo().IsEnum)169                    _source = new EnumDataSource(_count);170                else // Default171                    _source = new IntDataSource(_count);172            }173            else if (_source.DataType != parmType && WeConvert(_source.DataType, parmType))174            {175                _source = new RandomDataConverter(_source);176            }177            return _source.GetData(parameter);178            //// Copy the random _values into the data array179            //// and call the base class which may need to180            //// convert them to another type.181            //this.data = new object[values.Count];182            //for (int i = 0; i < values.Count; i++)183            //    this.data[i] = values[i];184            //return base.GetData(parameter);185        }186        private bool WeConvert(Type sourceType, Type targetType)187        {188            if (targetType == typeof(short) || targetType == typeof(ushort) || targetType == typeof(byte) || targetType == typeof(sbyte))189                return sourceType == typeof(int);190            if (targetType == typeof(decimal))191                return sourceType == typeof(int) || sourceType == typeof(double);192            193            return false;194        }195        #endregion196        #region Nested DataSource Classes197        #region RandomDataSource198        abstract class RandomDataSource : IParameterDataSource199        {200            public Type DataType { get; protected set; }201            public abstract IEnumerable GetData(IParameterInfo parameter);202        }203        abstract class RandomDataSource<T> : RandomDataSource204        {205            private T _min;206            private T _max;207            private int _count;208            private bool _inRange;209            protected Randomizer _randomizer;210            protected RandomDataSource(int count)211            {212                _count = count;213                _inRange = false;214                DataType = typeof(T);215            }216            protected RandomDataSource(T min, T max, int count)217            {218                _min = min;219                _max = max;220                _count = count;221                _inRange = true;222                DataType = typeof(T);223            }224            public override IEnumerable GetData(IParameterInfo parameter)225            {226                //Guard.ArgumentValid(parameter.ParameterType == typeof(T), "Parameter type must be " + typeof(T).Name, "parameter");227                _randomizer = Randomizer.GetRandomizer(parameter.ParameterInfo);228                for (int i = 0; i < _count; i++)229                    yield return _inRange230                        ? GetNext(_min, _max)231                        : GetNext();232            }233            protected abstract T GetNext();234            protected abstract T GetNext(T min, T max);235        }236        #endregion237        #region RandomDataConverter238        class RandomDataConverter : RandomDataSource239        {240            IParameterDataSource _source;241            public RandomDataConverter(IParameterDataSource source)242            {243                _source = source;244            }245            public override IEnumerable GetData(IParameterInfo parameter)246            {247                Type parmType = parameter.ParameterType;248                foreach (object obj in _source.GetData(parameter))249                {250                    if (obj is int)251                    {252                        int ival = (int)obj; // unbox first253                        if (parmType == typeof(short))254                            yield return (short)ival;255                        else if (parmType == typeof(ushort))256                            yield return (ushort)ival;257                        else if (parmType == typeof(byte))258                            yield return (byte)ival;259                        else if (parmType == typeof(sbyte))260                            yield return (sbyte)ival;261                        else if (parmType == typeof(decimal))262                            yield return (decimal)ival;263                    }264                    else if (obj is double)265                    {266                        double d = (double)obj; // unbox first267                        if (parmType == typeof(decimal))268                            yield return (decimal)d;269                    }270                }271            }272        }273        #endregion274        #region IntDataSource275        class IntDataSource : RandomDataSource<int>276        {277            public IntDataSource(int count) : base(count) { }278            public IntDataSource(int min, int max, int count) : base(min, max, count) { }279            protected override int GetNext()280            {281                return _randomizer.Next();282            }283            protected override int GetNext(int min, int max)284            {285                return _randomizer.Next(min, max);286            }287        }288        #endregion289        #region UIntDataSource290        class UIntDataSource : RandomDataSource<uint>291        {292            public UIntDataSource(int count) : base(count) { }293            public UIntDataSource(uint min, uint max, int count) : base(min, max, count) { }294            protected override uint GetNext()295            {296                return _randomizer.NextUInt();297            }298            protected override uint GetNext(uint min, uint max)299            {300                return _randomizer.NextUInt(min, max);301            }302        }303        #endregion304        #region LongDataSource305        class LongDataSource : RandomDataSource<long>306        {307            public LongDataSource(int count) : base(count) { }308            public LongDataSource(long min, long max, int count) : base(min, max, count) { }309            protected override long GetNext()310            {311                return _randomizer.NextLong();312            }313            protected override long GetNext(long min, long max)314            {315                return _randomizer.NextLong(min, max);316            }317        }318        #endregion319        #region ULongDataSource320        class ULongDataSource : RandomDataSource<ulong>321        {322            public ULongDataSource(int count) : base(count) { }323            public ULongDataSource(ulong min, ulong max, int count) : base(min, max, count) { }324            protected override ulong GetNext()325            {326                return _randomizer.NextULong();327            }328            protected override ulong GetNext(ulong min, ulong max)329            {330                return _randomizer.NextULong(min, max);331            }332        }333        #endregion334        #region ShortDataSource335        class ShortDataSource : RandomDataSource<short>336        {337            public ShortDataSource(int count) : base(count) { }338            public ShortDataSource(short min, short max, int count) : base(min, max, count) { }339            protected override short GetNext()340            {341                return _randomizer.NextShort();342            }343            protected override short GetNext(short min, short max)344            {345                return _randomizer.NextShort(min, max);346            }347        }348        #endregion349        #region UShortDataSource350        class UShortDataSource : RandomDataSource<ushort>351        {352            public UShortDataSource(int count) : base(count) { }353            public UShortDataSource(ushort min, ushort max, int count) : base(min, max, count) { }354            protected override ushort GetNext()355            {356                return _randomizer.NextUShort();357            }358            protected override ushort GetNext(ushort min, ushort max)359            {360                return _randomizer.NextUShort(min, max);361            }362        }363        #endregion364        #region DoubleDataSource365        class DoubleDataSource : RandomDataSource<double>366        {367            public DoubleDataSource(int count) : base(count) { }368            public DoubleDataSource(double min, double max, int count) : base(min, max, count) { }369            protected override double GetNext()370            {371                return _randomizer.NextDouble();372            }373            protected override double GetNext(double min, double max)374            {375                return _randomizer.NextDouble(min, max);376            }377        }378        #endregion379        #region FloatDataSource380        class FloatDataSource : RandomDataSource<float>381        {382            public FloatDataSource(int count) : base(count) { }383            public FloatDataSource(float min, float max, int count) : base(min, max, count) { }384            protected override float GetNext()385            {386                return _randomizer.NextFloat();387            }388            protected override float GetNext(float min, float max)389            {390                return _randomizer.NextFloat(min, max);391            }392        }393        #endregion394        #region ByteDataSource395        class ByteDataSource : RandomDataSource<byte>396        {397            public ByteDataSource(int count) : base(count) { }398            public ByteDataSource(byte min, byte max, int count) : base(min, max, count) { }399            protected override byte GetNext()400            {401                return _randomizer.NextByte();402            }403            protected override byte GetNext(byte min, byte max)404            {405                return _randomizer.NextByte(min, max);406            }407        }408        #endregion409        #region SByteDataSource410        class SByteDataSource : RandomDataSource<sbyte>411        {412            public SByteDataSource(int count) : base(count) { }413            public SByteDataSource(sbyte min, sbyte max, int count) : base(min, max, count) { }414            protected override sbyte GetNext()415            {416                return _randomizer.NextSByte();417            }418            protected override sbyte GetNext(sbyte min, sbyte max)419            {420                return _randomizer.NextSByte(min, max);421            }422        }423        #endregion424        #region EnumDataSource425        class EnumDataSource : RandomDataSource426        {427            private int _count;...

1using NUnit.Framework;2using System;3using System.Collections.Generic;4using System.IO;5using System.Linq;6using System.Text;7using System.Threading.Tasks;8{9    {10        [Test, TestCaseSource(typeof(ByteDataSource), "GetBytes")]11        public void TestMethod(byte[] bytes)12        {13            Console.WriteLine(bytes.Length);14        }15    }16}17using NUnit.Framework;18using System;19using System.Collections.Generic;20using System.IO;21using System.Linq;22using System.Text;23using System.Threading.Tasks;24{25    {26        public static byte[][] GetBytes()27        {28            byte[] bytes = new byte[] { 1, 2, 3, 4 };29            return new byte[][] { bytes };30        }31    }32}33using NUnit.Framework;34using System;35using System.Collections.Generic;36using System.IO;37using System.Linq;38using System.Text;39using System.Threading.Tasks;40{41    {42        [Test, TestCaseSource(typeof(ByteDataSource), "GetBytes")]43        public void TestMethod(byte[] bytes)44        {45            Console.WriteLine(bytes.Length);46        }47    }48}49using NUnit.Framework;50using System;51using System.Collections.Generic;52using System.IO;53using System.Linq;54using System.Text;55using System.Threading.Tasks;56{57    {58        public static byte[][] GetBytes()59        {60            byte[] bytes = new byte[] { 1, 2, 3, 4 };61            return new byte[][] { bytes };62        }63    }64}65using NUnit.Framework;66using System;67using System.Collections.Generic;68using System.IO;69using System.Linq;70using System.Text;71using System.Threading.Tasks;72{

1using NUnit.Framework;2using System;3using System.Collections.Generic;4using System.Linq;5using System.Text;6using System.Threading.Tasks;7using System.IO;8{9    {10        public void TestMethod1()11        {12            string path = @"C:\Users\user\Desktop\Test.txt";13            ByteDataSource bs = new ByteDataSource(path);14            byte[] data = bs.GetData();15            Assert.AreEqual(5, data.Length);16        }17    }18}19using NUnit.Framework;20using System;21using System.Collections.Generic;22using System.Linq;23using System.Text;24using System.Threading.Tasks;25using System.IO;26{27    {28        public void TestMethod1()29        {30            string path = @"C:\Users\user\Desktop\Test.txt";31            ByteDataSource bs = new ByteDataSource(path);32            byte[] data = bs.GetData();33            Assert.AreEqual(5, data.Length);34        }35    }36}37using NUnit.Framework;38using System;39using System.Collections.Generic;40using System.Linq;41using System.Text;42using System.Threading.Tasks;43using System.IO;44{45    {46        public void TestMethod1()47        {48            string path = @"C:\Users\user\Desktop\Test.txt";49            ByteDataSource bs = new ByteDataSource(path);50            byte[] data = bs.GetData();51            Assert.AreEqual(5, data.Length);52        }53    }54}55using NUnit.Framework;56using System;57using System.Collections.Generic;58using System.Linq;59using System.Text;60using System.Threading.Tasks;61using System.IO;62{63    {64        public void TestMethod1()65        {66            string path = @"C:\Users\user\Desktop\Test.txt";67            ByteDataSource bs = new ByteDataSource(path);68            byte[] data = bs.GetData();69            Assert.AreEqual(5, data.Length);70        }71    }72}

1using System;2using System.Collections.Generic;3using System.Linq;4using System.Text;5using System.Threading.Tasks;6using NUnit.Framework;7{8    {9        {10            {11                yield return new TestCaseData(1, 2, 3);12                yield return new TestCaseData(1, 2, 3);13                yield return new TestCaseData(1, 2, 3);14                yield return new TestCaseData(1, 2, 3);15            }16        }17    }18    {19        [Test, TestCaseSource(typeof(ByteDataSource), "GetTestCases")]20        public void TestMethod(int a, int b, int c)21        {22            Console.WriteLine(a + b + c);23        }24    }25}26using System;27using System.Collections.Generic;28using System.Linq;29using System.Text;30using System.Threading.Tasks;31using NUnit.Framework;32{33    {34        {35            {36                yield return new TestCaseData(1, 2, 3);37                yield return new TestCaseData(1, 2, 3);38                yield return new TestCaseData(1, 2, 3);39                yield return new TestCaseData(1, 2, 3);40            }41        }42    }43    {44        [Test, TestCaseSource(typeof(ByteDataSource), "GetTestCases")]45        public void TestMethod(int a, int b, int c)46        {47            Console.WriteLine(a + b + c);48        }49    }50}51using System;52using System.Collections.Generic;53using System.Linq;54using System.Text;55using System.Threading.Tasks;56using NUnit.Framework;57{58    {59        {60            {61                yield return new TestCaseData(1, 2, 3);62                yield return new TestCaseData(1, 2, 3);63                yield return new TestCaseData(1

1using System;2using System.Collections.Generic;3using System.Linq;4using System.Text;5using NUnit.Framework;6{7    {8        {9            {10                yield return new TestCaseData(1, 2, 3);11                yield return new TestCaseData(4, 5, 9);12                yield return new TestCaseData(5, 6, 11);13                yield return new TestCaseData(7, 8, 15);14            }15        }16    }17}18using System;19using System.Collections.Generic;20using System.Linq;21using System.Text;22using NUnit.Framework;23{24    {25        {26            {27                yield return new TestCaseData(1, 2, 3);28                yield return new TestCaseData(4, 5, 9);29                yield return new TestCaseData(5, 6, 11);30                yield return new TestCaseData(7, 8, 15);31            }32        }33    }34}35using System;36using System.Collections.Generic;37using System.Linq;38using System.Text;39using NUnit.Framework;40{41    {42        {43            {44                yield return new TestCaseData(1, 2, 3);45                yield return new TestCaseData(4, 5, 9);46                yield return new TestCaseData(5, 6, 11);47                yield return new TestCaseData(7, 8, 15);48            }49        }50    }51}52using System;53using System.Collections.Generic;54using System.Linq;55using System.Text;56using NUnit.Framework;57{58    {59        {60            {61                yield return new TestCaseData(1, 2, 3);62                yield return new TestCaseData(4, 5, 9);

1using NUnit.Framework;2using System;3using System.Collections.Generic;4using System.Linq;5using System.Text;6using System.Threading.Tasks;7using System.IO;8using System.Reflection;9using System.Collections;10{11    {12        [Test, TestCaseSource(typeof(ByteDataSource), "TestCases")]13        public void TestMethod(int a, int b, int expected)14        {15            Assert.AreEqual(expected, a + b);16        }17    }18    {19        {20            {21                yield return new TestCaseData(1, 2, 3).SetName("Addition of 1 and 2");22                yield return new TestCaseData(2, 3, 5).SetName("Addition of 2 and 3");23                yield return new TestCaseData(3, 4, 7).SetName("Addition of 3 and 4");24            }25        }26    }27}28using System;29using System.Collections.Generic;30using System.Linq;31using System.Text;32using System.Threading.Tasks;33using System.IO;34using System.Reflection;35using System.Collections;36using OfficeOpenXml;37{38    {39        {40            {41                string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);42                string excelPath = Path.Combine(path, "TestData.xlsx");43                using (ExcelPackage excelPackage = new ExcelPackage(new FileInfo(excelPath)))44                {45                    ExcelWorksheet excelWorksheet = excelPackage.Workbook.Worksheets[1];

1using NUnit.Framework;2{3    {4        static void Main(string[] args)5        {6        }7    }8    {9        [Test, TestCaseSource(typeof(ByteDataSourceClass), "ByteDataSource")]10        public void TestMethod1(byte b)11        {12            System.Console.WriteLine(b);13        }14        public static Byte[] ByteDataSource()15        {16            return new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };17        }18    }19}

1using NUnit.Framework;2using System;3using System.IO;4using System.Text;5{6    {7        [TestCaseSource(typeof(ByteDataSource), "TestCases")]8        public void TestMethod1(string input, string expected)9        {10            Assert.AreEqual(expected, input);11        }12    }13    {14        {15            new object[] { "Hello", "Hello" },16            new object[] { "World", "World" },17            new object[] { "Test", "Test" },18            new object[] { "NUnit", "NUnit" }19        };20    }21}22NUnit Console Runner 3.12.0 (.NET 4.0.30319.42000)23Copyright (C) 2019 Charlie Poole, Rob P

1using NUnit.Framework;2using System;3using System.IO;4using System.Text;5{6    {7        [Test, TestCaseSource("GetData")]8        public void TestMethod1(byte[] data)9        {10            Console.WriteLine("data = {0}", data);11        }12        static object[] GetData()13        {14            MemoryStream ms = new MemoryStream();15            BinaryWriter bw = new BinaryWriter(ms);16            bw.Write(1);17            bw.Write(2);18            bw.Write(3);19            bw.Write(4);20            bw.Write(5);21            bw.Close();22            byte[] data = ms.ToArray();

1using System;2using System.Collections.Generic;3using NUnit.Framework;4{5    {6        [TestCaseSource(typeof(ByteDataSource), "TestCase")]7        public void TestMethod(byte i)8        {9            Assert.AreEqual(1, i);10        }11    }12}13using System;14using System.Collections.Generic;15using NUnit.Framework;16{17    {18        [TestCaseSource(typeof(ByteDataSource), "TestCase")]19        public void TestMethod(byte i)20        {21            Assert.AreEqual(1, i);22        }23    }24}25using System;26using System.Collections.Generic;27using NUnit.Framework;28{29    {30        [TestCaseSource(typeof(ByteDataSource), "TestCase")]31        public void TestMethod(byte i)32        {33            Assert.AreEqual(1, i);34        }35    }36}37using System;38using System.Collections.Generic;39using NUnit.Framework;40{41    {42        [TestCaseSource(typeof(ByteDataSource), "TestCase")]43        public void TestMethod(byte i)44        {45            Assert.AreEqual(1, i);46        }47    }48}49using System;50using System.Collections.Generic;51using NUnit.Framework;52{53    {54        [TestCaseSource(typeof(ByteDataSource), "TestCase")]55        public void TestMethod(byte i)56        {57            Assert.AreEqual(1, i);58        }59    }60}61using System;62using System.Collections.Generic;63using System.IO;64using System.Linq;65using System.Text;66using System.Threading.Tasks;67using NUnit.Framework;68{69    {70        {71            {