Ejemplo n.º 1
0
        private static decimal GetMaxValueAndCheckRange(DataGenerationHint[] hints, out decimal minValue, ref int scale)
        {
            decimal maxValue = GetNumericMaxValueAndCheckRange(hints, decimal.MinValue, decimal.MaxValue, out minValue);

            int?precisionFromHint = hints.OfType <NumericPrecisionHint>().Any() ? hints.OfType <NumericPrecisionHint>().Min(h => h.Value) : (int?)null;
            int?scaleFromHint     = hints.OfType <NumericScaleHint>().Any() ? hints.OfType <NumericScaleHint>().Min(h => h.Value) : (int?)null;

            if (!precisionFromHint.HasValue && !scaleFromHint.HasValue)
            {
                scale = -1;
            }
            else
            {
                scale = !scaleFromHint.HasValue ? Math.Min(precisionFromHint.Value, scale) : scaleFromHint.Value;
                DataGenerationUtilities.CheckNumericScale(scale);

                minValue = AdjustMin(minValue, scale);
                maxValue = AdjustMax(maxValue, scale);

                if (precisionFromHint.HasValue)
                {
                    DataGenerationUtilities.CheckNumericPrecisionAndScale(precisionFromHint.Value, scale);
                    decimal maxBasedOnPrecisionAndScale = (decimal)Math.Pow(10, precisionFromHint.Value - scale) - (1 / (decimal)Math.Pow(10, scale));
                    decimal minBasedOnPrecisionAndScale = -maxBasedOnPrecisionAndScale;

                    minValue = Math.Max(minValue, minBasedOnPrecisionAndScale);
                    maxValue = Math.Min(maxValue, maxBasedOnPrecisionAndScale);
                }

                ExceptionUtilities.CheckValidRange(minValue, "minimum value based on hints", maxValue, "maximum value based on hints");
            }

            return(maxValue);
        }
Ejemplo n.º 2
0
 /// <summary>
 /// DateTimeOffset 'FromSeed' strategy that returns DateTimeOffset(seed, offset).
 /// </summary>
 /// <param name="offset">The offset.</param>
 /// <returns>DateTimeOffset 'FromSeed' delegate.</returns>
 public static Func <long, DateTimeOffset> DateTimeOffsetFromSeed(TimeSpan offset)
 {
     return(delegate(long seed)
     {
         try
         {
             return new DateTimeOffset(seed, offset);
         }
         catch (ArgumentOutOfRangeException ex)
         {
             throw DataGenerationUtilities.FromSeedFailedException <DateTimeOffset>(seed, ex);
         }
     });
 }
Ejemplo n.º 3
0
        /// <summary>
        /// FromSeed strategy that converts seed to the targeted type using IConvertible.
        /// </summary>
        /// <typeparam name="TData">The targeted type.</typeparam>
        /// <returns>'FromSeed' delegate.</returns>
        /// <remarks>The <typeparamref name="TData"/> such that long can be converted to.</remarks>
        public static Func <long, TData> ConvertSeed <TData>()
        {
            Type clrType = typeof(TData);

            if (!supportedTypesForConvertSeed.Contains(typeof(TData)))
            {
                throw new TaupoNotSupportedException("This strategy is not supported for the type " + clrType.FullName + ". Try other strategies.");
            }

            return(delegate(long seed)
            {
                try
                {
                    var value = seed.ConvertToType <TData>();
                    return value;
                }
                catch (OverflowException ex)
                {
                    throw DataGenerationUtilities.FromSeedFailedException <TData>(seed, ex);
                }
            });
        }