private void TestDefault(StringConvertOptions opts)
        {
            // Returns a value
            Assert.NotNull(opts);

            // Always the same instance
            Assert.Same(opts, StringConvertOptions.Default);

            // Expected configuration
            Assert.Equal(StringAsNullOption.NullReference, opts.AsNullOption);
            Assert.Equal(TrimStringFlags.TrimAll, opts.TrimFlags);
        }
Beispiel #2
0
        public void FromConvertOptions()
        {
            var stringOpts  = new StringConvertOptions(StringAsNullOption.NullReference, TrimStringFlags.None);
            var valOpts     = new ValueTypeConvertOptions(ValueTypeConvertFlags.None);
            var complexOpts = new ComplexNumberConvertOptions(ComplexNumberElement.Real);
            var boolOpts    = new BooleanConvertOptions(new[] { bool.TrueString }, new[] { bool.FalseString });
            var enumOpts    = new EnumConvertOptions(UndefinedValueOption.Throw, UndefinedValueOption.Throw);
            var numberOpts  = new NumberConvertOptions(ParseNumericStringFlags.None);

            var opts = new ConvertOptions(new OptionSet[] { stringOpts, valOpts, complexOpts, boolOpts, enumOpts, numberOpts });

            var builder = ConvertOptionsBuilder.FromConvertOptions(opts);

            Assert.Equal(6, builder.Count());
            Assert.Contains(stringOpts, builder);
            Assert.Contains(valOpts, builder);
            Assert.Contains(complexOpts, builder);
            Assert.Contains(boolOpts, builder);
            Assert.Contains(enumOpts, builder);
            Assert.Contains(numberOpts, builder);
        }
        public void AsNullOption()
        {
            var opts = new StringConvertOptions(StringAsNullOption.EmptyString, TrimStringFlags.None);

            Assert.Equal(StringAsNullOption.EmptyString, opts.AsNullOption);

            Assert.True(opts.EmptyStringAsNull);
            Assert.False(opts.WhitespaceAsNull);

            opts = new StringConvertOptions(StringAsNullOption.NullReference, TrimStringFlags.None);
            Assert.Equal(StringAsNullOption.NullReference, opts.AsNullOption);

            Assert.False(opts.EmptyStringAsNull);
            Assert.False(opts.WhitespaceAsNull);

            opts = new StringConvertOptions(StringAsNullOption.Whitespace, TrimStringFlags.None);
            Assert.Equal(StringAsNullOption.Whitespace, opts.AsNullOption);

            Assert.True(opts.EmptyStringAsNull);
            Assert.True(opts.WhitespaceAsNull);
        }
        public void TrimFlags()
        {
            var opts = new StringConvertOptions(StringAsNullOption.NullReference, TrimStringFlags.TrimStart);

            Assert.Equal(TrimStringFlags.TrimStart, opts.TrimFlags);

            Assert.False(opts.TrimNone);
            Assert.True(opts.TrimStart);
            Assert.False(opts.TrimEnd);
            Assert.False(opts.TrimAll);


            opts = new StringConvertOptions(StringAsNullOption.NullReference, TrimStringFlags.TrimEnd);
            Assert.Equal(TrimStringFlags.TrimEnd, opts.TrimFlags);

            Assert.False(opts.TrimNone);
            Assert.False(opts.TrimStart);
            Assert.True(opts.TrimEnd);
            Assert.False(opts.TrimAll);


            opts = new StringConvertOptions(StringAsNullOption.NullReference, TrimStringFlags.None);
            Assert.Equal(TrimStringFlags.None, opts.TrimFlags);

            Assert.True(opts.TrimNone);
            Assert.False(opts.TrimStart);
            Assert.False(opts.TrimEnd);
            Assert.False(opts.TrimAll);


            opts = new StringConvertOptions(StringAsNullOption.NullReference, TrimStringFlags.TrimAll);
            Assert.Equal(TrimStringFlags.TrimAll, opts.TrimFlags);

            Assert.False(opts.TrimNone);
            Assert.True(opts.TrimStart);
            Assert.True(opts.TrimEnd);
            Assert.True(opts.TrimAll);
        }
        public void Ctor()
        {
            var opts = new StringConvertOptions(StringAsNullOption.EmptyString, TrimStringFlags.TrimStart);

            Assert.NotNull(opts);
        }
Beispiel #6
0
        public static Dictionary <string, string> CreateDictionary(string value, char[] entriesSeparator, char[] keyValueSeparator, StringConvertOptions keyOptions, StringConvertOptions valueOptions)
        {
            if (value != null)
            {
                var dict = new Dictionary <string, string>();

                var entries = value.Split(entriesSeparator, StringSplitOptions.RemoveEmptyEntries);

                foreach (var entry in entries)
                {
                    var entryKeyValue = entry.Split(keyValueSeparator, 2);

                    if (entryKeyValue.Length == 2)
                    {
                        var entryKey   = entryKeyValue[0].Trim().Convert(keyOptions);
                        var entryValue = entryKeyValue[1].Convert(valueOptions);

                        if (entryKey.Length > 0)
                        {
                            dict.Add(entryKey, entryValue);
                        }
                    }
                }

                return(dict);
            }
            else
            {
                return(null);
            }
        }
Beispiel #7
0
 public ConvertOptions(BooleanConvertOptions booleanOptions, EnumConvertOptions enumOptions, NumberConvertOptions numberOptions, StringConvertOptions stringOptions, ValueTypeConvertOptions valueTypeOptions, params OptionSet[] otherOptions);