Exemple #1
0
        public void WebSiteBasicExample()
        {
            FtMeta meta = new FtMeta();

            meta.LineCommentChar  = '~';
            meta.HeadingLineCount = 2;

            FtStringMetaField petNameMetaField = meta.FieldList.New(FtStandardDataType.String) as FtStringMetaField;

            petNameMetaField.Name = "PetName";
            FtFloatMetaField ageMetaField = meta.FieldList.New(FtStandardDataType.Float) as FtFloatMetaField;

            ageMetaField.Name = "Age";
            FtStringMetaField colorMetaField = meta.FieldList.New(FtStandardDataType.String) as FtStringMetaField;

            colorMetaField.Name = "Color";
            FtDateTimeMetaField dateReceivedMetaField = meta.FieldList.New(FtStandardDataType.DateTime) as FtDateTimeMetaField;

            dateReceivedMetaField.Name   = "DateReceived";
            dateReceivedMetaField.Format = "d MMM yyyy";
            FtDecimalMetaField priceMetaField = meta.FieldList.New(FtStandardDataType.Decimal) as FtDecimalMetaField;

            priceMetaField.Name = "Price";
            FtBooleanMetaField needsWalkingMetaField = meta.FieldList.New(FtStandardDataType.Boolean) as FtBooleanMetaField;

            needsWalkingMetaField.Name = "NeedsWalking";
            FtStringMetaField typeMetaField = meta.FieldList.New(FtStandardDataType.String) as FtStringMetaField;

            typeMetaField.Name = "Type";

            string           filePath       = Path.Combine(TestFolder, BasicExampleFileName);
            FtWriterSettings writerSettings = new FtWriterSettings();

            writerSettings.Declared                = true;
            writerSettings.MetaReferenceType       = FtMetaReferenceType.Embedded;
            writerSettings.EmbeddedMetaIndent      = true;
            writerSettings.EmbeddedMetaIndentChars = "  ";
            using (StreamWriter strmWriter = new StreamWriter(filePath, false, System.Text.Encoding.UTF8))
            {
                using (FtWriter writer = new FtWriter(meta, strmWriter, writerSettings))
                {
                    FtStringField   petNameField           = writer.FieldList.Get(petNameMetaField.Name) as FtStringField;
                    int             petNameFieldIndex      = writer.GetOrdinal(petNameMetaField.Name);
                    FtFloatField    ageField               = writer.FieldList.Get(ageMetaField.Name) as FtFloatField;
                    int             ageFieldIndex          = writer.GetOrdinal(ageMetaField.Name);
                    FtStringField   colorField             = writer.FieldList.Get(colorMetaField.Name) as FtStringField;
                    int             colorFieldIndex        = writer.GetOrdinal(colorMetaField.Name);
                    FtDateTimeField dateReceivedField      = writer.FieldList.Get(dateReceivedMetaField.Name) as FtDateTimeField;
                    int             dateReceivedFieldIndex = writer.GetOrdinal(dateReceivedMetaField.Name);
                    FtDecimalField  priceField             = writer.FieldList.Get(priceMetaField.Name) as FtDecimalField;
                    int             priceFieldIndex        = writer.GetOrdinal(priceMetaField.Name);
                    FtBooleanField  needsWalkingField      = writer.FieldList.Get(needsWalkingMetaField.Name) as FtBooleanField;
                    int             needsWalkingFieldIndex = writer.GetOrdinal(needsWalkingMetaField.Name);
                    FtStringField   typeField              = writer.FieldList.Get(typeMetaField.Name) as FtStringField;
                    int             typeFieldIndex         = writer.GetOrdinal(typeMetaField.Name);

                    for (int i = 0; i < headingArray.Length; i++)
                    {
                        petNameField.Headings[i]      = headingArray[i].PetName;
                        ageField.Headings[i]          = headingArray[i].Age;
                        colorField.Headings[i]        = headingArray[i].Color;
                        dateReceivedField.Headings[i] = headingArray[i].DateReceived;
                        priceField.Headings[i]        = headingArray[i].Price;
                        needsWalkingField.Headings[i] = headingArray[i].NeedsWalking;
                        typeField.Headings[i]         = headingArray[i].Type;
                    }

                    for (int i = 0; i < 2; i++)
                    {
                        if (recArray[i].PetName != null)
                        {
                            petNameField.Value = recArray[i].PetName;
                        }
                        if (recArray[i].Age.HasValue)
                        {
                            // test assigning to AsObject as Single
                            Single ageAsSingle = (Single)(recArray[i].Age.Value);
                            ageField.AsObject = ageAsSingle;
                            Assert.AreEqual <Single>(ageAsSingle, (Single)ageField.Value);

                            // test assigning to AsObject as Decimal
                            Decimal ageAsDecimal = (Decimal)(recArray[i].Age.Value);
                            ageField.AsObject = ageAsDecimal;
                            Assert.AreEqual <Decimal>(ageAsDecimal, (Decimal)ageField.Value);

                            // assign as Double
                            ageField.Value = recArray[i].Age.Value;
                        }
                        if (recArray[i].Color != null)
                        {
                            colorField.Value = recArray[i].Color;
                        }
                        if (recArray[i].DateReceived.HasValue)
                        {
                            dateReceivedField.Value = recArray[i].DateReceived.Value;
                        }
                        if (recArray[i].Price.HasValue)
                        {
                            // test assigning to AsObject as Single
                            Single priceAsSingle = (Single)(recArray[i].Price.Value);
                            priceField.AsObject = priceAsSingle;
                            Assert.AreEqual <Single>(priceAsSingle, (Single)priceField.Value);

                            // test assigning to AsObject as Double
                            Double priceAsDouble = (Double)(recArray[i].Price.Value);
                            priceField.AsObject = priceAsDouble;
                            Assert.AreEqual <Double>(priceAsDouble, (Double)priceField.Value);

                            // assign as Decimal
                            priceField.Value = recArray[i].Price.Value;
                        }
                        if (recArray[i].NeedsWalking.HasValue)
                        {
                            needsWalkingField.Value = recArray[i].NeedsWalking.Value;
                        }
                        if (recArray[i].Type != null)
                        {
                            typeField.Value = recArray[i].Type;
                        }

                        writer.Write();
                    }

                    for (int i = 2; i < 3; i++)
                    {
                        if (recArray[i].PetName == null)
                        {
                            writer.SetNull(i);
                        }
                        else
                        {
                            writer.SetString(petNameFieldIndex, recArray[i].PetName);
                        }
                        if (!recArray[i].Age.HasValue)
                        {
                            writer.SetNull(i);
                        }
                        else
                        {
                            // test assigning to AsObject as Single
                            Single ageAsSingle = (Single)recArray[i].Age.Value;
                            writer[ageMetaField.Name] = ageAsSingle;
                            Assert.AreEqual <Single>(ageAsSingle, (Single)ageField.Value);

                            // test assigning to AsObject as Decimal
                            Decimal ageAsDecimal = (Decimal)(recArray[i].Age.Value);
                            writer[ageMetaField.Name] = ageAsDecimal;
                            Assert.AreEqual <Decimal>(ageAsDecimal, (Decimal)ageField.Value);

                            // assign as Double
                            writer.SetDouble(ageFieldIndex, recArray[i].Age.Value);
                        }
                        if (recArray[i].Color == null)
                        {
                            writer.SetNull(i);
                        }
                        else
                        {
                            writer.SetString(colorFieldIndex, recArray[i].Color);
                        }
                        if (!recArray[i].DateReceived.HasValue)
                        {
                            writer.SetNull(i);
                        }
                        else
                        {
                            writer.SetDateTime(dateReceivedFieldIndex, recArray[i].DateReceived.Value);
                        }
                        if (!recArray[i].Price.HasValue)
                        {
                            writer.SetNull(i);
                        }
                        else
                        {
                            // test assigning to AsObject as Single
                            Single priceAsSingle = (Single)(recArray[i].Price.Value);
                            writer[priceField.Name] = priceAsSingle;
                            Assert.AreEqual <Single>(priceAsSingle, (Single)priceField.Value);

                            // test assigning to AsObject as Double
                            Double priceAsDouble = (Double)(recArray[i].Price.Value);
                            writer[priceField.Name] = priceAsDouble;
                            Assert.AreEqual <Double>(priceAsDouble, (Double)priceField.Value);

                            // assign as Decimal
                            writer.SetDecimal(priceFieldIndex, recArray[i].Price.Value);
                        }
                        if (!recArray[i].NeedsWalking.HasValue)
                        {
                            writer.SetNull(i);
                        }
                        else
                        {
                            writer.SetBoolean(needsWalkingFieldIndex, recArray[i].NeedsWalking.Value);
                        }
                        if (recArray[i].Type == null)
                        {
                            writer.SetNull(i);
                        }
                        else
                        {
                            writer.SetString(typeFieldIndex, recArray[i].Type);
                        }

                        writer.Write();
                    }

                    for (int i = 3; i < recArray.Length; i++)
                    {
                        if (recArray[i].PetName == null)
                        {
                            writer[petNameMetaField.Name] = null;
                        }
                        else
                        {
                            writer[petNameMetaField.Name] = recArray[i].PetName;
                        }
                        if (!recArray[i].Age.HasValue)
                        {
                            writer[ageMetaField.Name] = null;
                        }
                        else
                        {
                            // test assigning to AsObject as Single
                            Single ageAsSingle = (Single)recArray[i].Age.Value;
                            writer[ageMetaField.Name] = ageAsSingle;
                            Assert.AreEqual <Single>(ageAsSingle, (Single)ageField.Value);

                            // test assigning to AsObject as Decimal
                            Decimal ageAsDecimal = (Decimal)(recArray[i].Age.Value);
                            writer[ageMetaField.Name] = ageAsDecimal;
                            Assert.AreEqual <Decimal>(ageAsDecimal, (Decimal)ageField.Value);

                            // assign as Double
                            writer[ageMetaField.Name] = recArray[i].Age.Value;
                        }
                        if (recArray[i].Color == null)
                        {
                            writer[colorMetaField.Name] = null;
                        }
                        else
                        {
                            writer[colorMetaField.Name] = recArray[i].Color;
                        }
                        if (!recArray[i].DateReceived.HasValue)
                        {
                            writer[dateReceivedMetaField.Name] = null;
                        }
                        else
                        {
                            writer[dateReceivedMetaField.Name] = recArray[i].DateReceived.Value;
                        }
                        if (!recArray[i].Price.HasValue)
                        {
                            writer[priceMetaField.Name] = null;
                        }
                        else
                        {
                            // test assigning to AsObject as Single
                            Single priceAsSingle = (Single)(recArray[i].Price.Value);
                            writer[priceField.Name] = priceAsSingle;
                            Assert.AreEqual <Single>(priceAsSingle, (Single)priceField.Value);

                            // test assigning to AsObject as Double
                            Double priceAsDouble = (Double)(recArray[i].Price.Value);
                            writer[priceField.Name] = priceAsDouble;
                            Assert.AreEqual <Double>(priceAsDouble, (Double)priceField.Value);

                            // assign as Decimal
                            writer[priceMetaField.Name] = recArray[i].Price.Value;
                        }
                        if (!recArray[i].NeedsWalking.HasValue)
                        {
                            writer[needsWalkingMetaField.Name] = null;
                        }
                        else
                        {
                            writer[needsWalkingMetaField.Name] = recArray[i].NeedsWalking.Value;
                        }
                        if (recArray[i].Type == null)
                        {
                            writer[typeMetaField.Name] = null;
                        }
                        else
                        {
                            writer[typeMetaField.Name] = recArray[i].Type;
                        }

                        writer.Write();
                    }
                }
            }

            string DataFilePath = Path.Combine(DataFolder, BasicExampleFileName);

            if (!TextFilesAreEqual(filePath, DataFilePath))
            {
                Assert.Fail("BasicExample does not match Test Data");
            }
            else
            {
                using (FtReader ftReader = new FtReader())
                {
                    ftReader.Open(filePath);
                    using (StreamReader strmReader = new StreamReader(filePath))
                    {
                        Assert.AreEqual <bool>(true, ftReader.Declared);
                        Assert.AreEqual <bool>(true, ftReader.HeaderRead);
                        Assert.AreEqual <int>(headingArray.Length, ftReader.HeadingLineReadCount);
                        Assert.AreEqual <FtMetaReferenceType>(FtMetaReferenceType.Embedded, ftReader.MetaReferenceType);
                        Assert.AreEqual <FtLineType>(FtLineType.Heading, ftReader.LineType); // last line in header

                        FtStringField   petNameField           = ftReader.FieldList.Get(petNameMetaField.Name) as FtStringField;
                        int             petNameFieldIndex      = ftReader.GetOrdinal(petNameMetaField.Name);
                        FtFloatField    ageField               = ftReader.FieldList.Get(ageMetaField.Name) as FtFloatField;
                        int             ageFieldIndex          = ftReader.GetOrdinal(ageMetaField.Name);
                        FtStringField   colorField             = ftReader.FieldList.Get(colorMetaField.Name) as FtStringField;
                        int             colorFieldIndex        = ftReader.GetOrdinal(colorMetaField.Name);
                        FtDateTimeField dateReceivedField      = ftReader.FieldList.Get(dateReceivedMetaField.Name) as FtDateTimeField;
                        int             dateReceivedFieldIndex = ftReader.GetOrdinal(dateReceivedMetaField.Name);
                        FtDecimalField  priceField             = ftReader.FieldList.Get(priceMetaField.Name) as FtDecimalField;
                        int             priceFieldIndex        = ftReader.GetOrdinal(priceMetaField.Name);
                        FtBooleanField  needsWalkingField      = ftReader.FieldList.Get(needsWalkingMetaField.Name) as FtBooleanField;
                        int             needsWalkingFieldIndex = ftReader.GetOrdinal(needsWalkingMetaField.Name);
                        FtStringField   typeField              = ftReader.FieldList.Get(typeMetaField.Name) as FtStringField;
                        int             typeFieldIndex         = ftReader.GetOrdinal(typeMetaField.Name);

                        // skip comment lines
                        string strmLine;
                        do
                        {
                            strmLine = strmReader.ReadLine();
                        }while (strmLine[0] == ftReader.LineCommentChar);

                        for (int i = 0; i < headingArray.Length; i++)
                        {
                            strmLine = strmReader.ReadLine();

                            Assert.AreEqual <string>(headingArray[i].PetName, petNameField.Headings[i]);
                            Assert.AreEqual <string>(headingArray[i].Age, ageField.Headings[i]);
                            Assert.AreEqual <string>(headingArray[i].Color, colorField.Headings[i]);
                            Assert.AreEqual <string>(headingArray[i].DateReceived, dateReceivedField.Headings[i]);
                            Assert.AreEqual <string>(headingArray[i].Price, priceField.Headings[i]);
                            Assert.AreEqual <string>(headingArray[i].NeedsWalking, needsWalkingField.Headings[i]);
                            Assert.AreEqual <string>(headingArray[i].Type, typeField.Headings[i]);
                        }

                        for (int i = 0; i < recArray.Length; i++)
                        {
                            ftReader.Read();

                            Assert.AreEqual <string>(strmLine, ftReader.Line);
                            Assert.AreEqual <int>(-1, ftReader.IgnoreExtraCharsLinePosition);

                            Assert.AreEqual <int>(i + 1, ftReader.RecordCount);
                            Assert.AreEqual <int>(1, ftReader.TableCount);

                            if (recArray[i].PetName == null)
                            {
                                Assert.AreEqual <bool>(true, petNameField.IsNull());
                            }
                            else
                            {
                                Assert.AreEqual <string>(recArray[i].PetName, petNameField.Value);
                                Assert.AreEqual <object>(recArray[i].PetName, ftReader[petNameMetaField.Name]);
                                Assert.AreEqual <object>(recArray[i].PetName, ftReader[petNameFieldIndex]);
                                Assert.AreEqual <string>(recArray[i].PetName, ftReader.GetString(petNameFieldIndex));
                            }
                            if (!recArray[i].Age.HasValue)
                            {
                                Assert.AreEqual <bool>(true, ageField.IsNull());
                                Assert.AreEqual <bool>(true, ftReader.IsDBNull(ageFieldIndex));
                            }
                            else
                            {
                                Assert.AreEqual <double>(recArray[i].Age.Value, ageField.Value);
                                Assert.AreEqual <object>(recArray[i].Age, ftReader[ageMetaField.Name]);
                                Assert.AreEqual <object>(recArray[i].Age, ftReader[ageFieldIndex]);
                                Assert.AreEqual <double>(recArray[i].Age.Value, ftReader.GetDouble(ageFieldIndex));
                            }
                            if (recArray[i].Color == null)
                            {
                                Assert.AreEqual <bool>(true, colorField.IsNull());
                            }
                            else
                            {
                                Assert.AreEqual <string>(recArray[i].Color, colorField.Value);
                                Assert.AreEqual <object>(recArray[i].Color, ftReader[colorMetaField.Name]);
                                Assert.AreEqual <object>(recArray[i].Color, ftReader[colorFieldIndex]);
                                Assert.AreEqual <string>(recArray[i].Color, ftReader.GetString(colorFieldIndex));
                            }
                            if (!recArray[i].DateReceived.HasValue)
                            {
                                Assert.AreEqual <bool>(true, dateReceivedField.IsNull());
                            }
                            else
                            {
                                Assert.AreEqual <DateTime>(recArray[i].DateReceived.Value, dateReceivedField.Value);
                                Assert.AreEqual <object>(recArray[i].DateReceived, ftReader[dateReceivedMetaField.Name]);
                                Assert.AreEqual <object>(recArray[i].DateReceived, ftReader[dateReceivedFieldIndex]);
                                Assert.AreEqual <DateTime>(recArray[i].DateReceived.Value, ftReader.GetDateTime(dateReceivedFieldIndex));
                            }
                            if (!recArray[i].Price.HasValue)
                            {
                                Assert.AreEqual <bool>(true, priceField.IsNull());
                            }
                            else
                            {
                                Assert.AreEqual <decimal>(recArray[i].Price.Value, priceField.Value);
                                Assert.AreEqual <object>(recArray[i].Price, ftReader[priceMetaField.Name]);
                                Assert.AreEqual <object>(recArray[i].Price, ftReader[priceFieldIndex]);
                                Assert.AreEqual <decimal>(recArray[i].Price.Value, ftReader.GetDecimal(priceFieldIndex));
                            }
                            if (!recArray[i].NeedsWalking.HasValue)
                            {
                                Assert.AreEqual <bool>(true, needsWalkingField.IsNull());
                            }
                            else
                            {
                                Assert.AreEqual <bool>(recArray[i].NeedsWalking.Value, needsWalkingField.Value);
                                Assert.AreEqual <object>(recArray[i].NeedsWalking, ftReader[needsWalkingMetaField.Name]);
                                Assert.AreEqual <object>(recArray[i].NeedsWalking, ftReader[needsWalkingFieldIndex]);
                                Assert.AreEqual <bool>(recArray[i].NeedsWalking.Value, ftReader.GetBoolean(needsWalkingFieldIndex));
                            }
                            if (recArray[i].Type == null)
                            {
                                Assert.AreEqual <bool>(true, typeField.IsNull());
                            }
                            else
                            {
                                Assert.AreEqual <string>(recArray[i].Type, typeField.Value);
                                Assert.AreEqual <object>(recArray[i].Type, ftReader[typeMetaField.Name]);
                                Assert.AreEqual <object>(recArray[i].Type, ftReader[typeFieldIndex]);
                                Assert.AreEqual <string>(recArray[i].Type, ftReader.GetString(typeFieldIndex));
                            }

                            strmLine = strmReader.ReadLine();
                        }

                        Assert.AreEqual <bool>(false, ftReader.Read());
                        Assert.AreEqual <int>(recArray.Length, ftReader.RecordCount);
                    }

                    // repeat but read header separately
                    ftReader.Open(filePath, false);

                    Assert.AreEqual <int>(0, ftReader.HeadingLineReadCount);
                    Assert.AreEqual <int>(0, ftReader.RecordCount);
                    Assert.AreEqual <int>(0, ftReader.TableCount);

                    Assert.AreEqual <bool>(true, ftReader.Declared);
                    Assert.AreEqual <bool>(false, ftReader.HeaderRead);

                    ftReader.ReadHeader();

                    Assert.AreEqual <bool>(true, ftReader.HeaderRead);
                    Assert.AreEqual <int>(headingArray.Length, ftReader.HeadingLineReadCount);
                    Assert.AreEqual <FtMetaReferenceType>(FtMetaReferenceType.Embedded, ftReader.MetaReferenceType);
                    Assert.AreEqual <FtLineType>(FtLineType.Heading, ftReader.LineType); // last line in header

                    ftReader.SeekEnd();
                    Assert.AreEqual <int>(recArray.Length, ftReader.RecordCount);

                    // repeat but reading each line individually
                    ftReader.Open(filePath, false);
                    Assert.AreEqual <bool>(false, ftReader.HeaderRead);
                    Assert.AreEqual <int>(0, ftReader.HeadingLineReadCount);
                    Assert.AreEqual <int>(0, ftReader.RecordCount);
                    Assert.AreEqual <int>(0, ftReader.TableCount);

                    ftReader.ReadLine();
                    Assert.AreEqual <FtLineType>(FtLineType.Signature, ftReader.LineType);
                    ftReader.ReadLine();
                    Assert.AreEqual <FtLineType>(FtLineType.Declaration2, ftReader.LineType);

                    Assert.AreEqual <FtMetaReferenceType>(FtMetaReferenceType.Embedded, ftReader.MetaReferenceType);

                    for (int i = 0; i < 10; i++)
                    {
                        ftReader.ReadLine();
                        if (i == 0)
                        {
                            Assert.AreEqual <FtLineType>(FtLineType.Comment, ftReader.LineType);
                        }
                        else
                        {
                            Assert.AreEqual <FtLineType>(FtLineType.EmbeddedMeta, ftReader.LineType);
                        }
                    }
                    for (int i = 0; i < headingArray.Length; i++)
                    {
                        ftReader.ReadLine();
                        Assert.AreEqual <FtLineType>(FtLineType.Heading, ftReader.LineType);
                    }

                    Assert.AreEqual <int>(headingArray.Length, ftReader.HeadingLineReadCount);
                    Assert.AreEqual <bool>(true, ftReader.HeaderRead);

                    for (int i = 0; i < recArray.Length; i++)
                    {
                        ftReader.ReadLine();
                        Assert.AreEqual <FtLineType>(FtLineType.Record, ftReader.LineType);
                    }
                    Assert.AreEqual <bool>(false, ftReader.Read());
                    Assert.AreEqual <int>(recArray.Length, ftReader.RecordCount);
                    Assert.AreEqual <int>(1, ftReader.TableCount);
                }
            }
        }
Exemple #2
0
        public void MetaVariations()
        {
            foreach (MetaVariation variation in metaVariationArray)
            {
                FtMeta meta = new FtMeta();
                variation.Properties.LoadIntoMeta(ref meta);

                foreach (MetaFieldDefinition metaFieldDefinition in metaFieldDefinitionArray)
                {
                    FtMetaField metaField = meta.FieldList.New(metaFieldDefinition.DataType);
                    // metaField.Name = "Field" + idx++.ToString();
                    metaFieldDefinition.Properties.LoadIntoMetaField(ref metaField, true);

                    switch (metaFieldDefinition.DataType)
                    {
                    case FtStandardDataType.Boolean:
                        FtBooleanMetaField booleanMetaField = metaField as FtBooleanMetaField;
                        booleanMetaField.Styles    = BooleanMetaFieldStyles;
                        booleanMetaField.FalseText = BooleanMetaFieldFalseText;
                        booleanMetaField.TrueText  = BooleanMetaFieldTrueText;
                        break;

                    case FtStandardDataType.String:
                        FtStringMetaField stringMetaField = metaField as FtStringMetaField;
                        stringMetaField.Value = StringMetaFieldValue;
                        break;

                    case FtStandardDataType.Float:
                        FtFloatMetaField floatMetaField = metaField as FtFloatMetaField;
                        floatMetaField.Format = FloatMetaFieldFormat;
                        floatMetaField.Styles = FloatMetaFieldStyles;
                        break;

                    case FtStandardDataType.DateTime:
                        FtDateTimeMetaField dateTimeMetaField = metaField as FtDateTimeMetaField;
                        dateTimeMetaField.Format = DateTimeMetaFieldFormat;
                        dateTimeMetaField.Styles = DateTimeMetaFieldStyles;
                        dateTimeMetaField.Value  = DateTimeMetaFieldValue;
                        break;
                    }
                }

                string    filePath = Path.Combine(TestFolder, variation.FileName);
                XmlWriter writer   = XmlWriter.Create(filePath, xmlWriterSettings);
                FtMetaSerializer.Serialize(meta, writer);
                writer.Close();

                string DataFilePath = Path.Combine(DataFolder, variation.FileName);
                if (!TextFilesAreEqual(filePath, DataFilePath))
                {
                    Assert.Fail(variation.FileName + " does not match Test Data");
                }
                else
                {
                    FtMeta deserialisedMeta = FtMetaSerializer.Deserialize(filePath);

                    variation.Properties.AssertMetaAreEqual(meta);

                    Assert.AreEqual <int>(metaFieldDefinitionArray.Length, deserialisedMeta.FieldList.Count);

                    for (int i = 0; i < deserialisedMeta.FieldList.Count; i++)
                    {
                        FtMetaField metaField = deserialisedMeta.FieldList[i];
                        metaFieldDefinitionArray[i].Properties.AssertMetaFieldAreEqual(metaField, true);

                        switch (metaFieldDefinitionArray[i].DataType)
                        {
                        case FtStandardDataType.Boolean:
                            FtBooleanMetaField booleanMetaField = metaField as FtBooleanMetaField;
                            Assert.AreEqual <FtBooleanStyles>(BooleanMetaFieldStyles, booleanMetaField.Styles);
                            Assert.AreEqual <string>(BooleanMetaFieldFalseText, booleanMetaField.FalseText);
                            Assert.AreEqual <string>(BooleanMetaFieldTrueText, booleanMetaField.TrueText);
                            break;

                        case FtStandardDataType.String:
                            FtStringMetaField stringMetaField = metaField as FtStringMetaField;
                            Assert.AreEqual <string>(StringMetaFieldValue, stringMetaField.Value);
                            break;

                        case FtStandardDataType.Float:
                            FtFloatMetaField floatMetaField = metaField as FtFloatMetaField;
                            Assert.AreEqual <string>(FloatMetaFieldFormat, floatMetaField.Format);
                            Assert.AreEqual <NumberStyles>(FloatMetaFieldStyles, floatMetaField.Styles);
                            break;

                        case FtStandardDataType.DateTime:
                            FtDateTimeMetaField dateTimeMetaField = metaField as FtDateTimeMetaField;
                            Assert.AreEqual <string>(DateTimeMetaFieldFormat, dateTimeMetaField.Format);
                            Assert.AreEqual <DateTimeStyles>(DateTimeMetaFieldStyles, dateTimeMetaField.Styles);
                            Assert.AreEqual <DateTime>(DateTimeMetaFieldValue, dateTimeMetaField.Value);
                            break;
                        }
                    }
                }
            }
        }
Exemple #3
0
        public void AllDefaults()
        {
            // Creates Meta with one sequence with one field of each type
            // Sets Meta and fields and sequence redirects properties to default values
            // Saves to XML (Serialize)
            // Compares XML to Expected
            // Creates Meta from XML (Deserialize)
            // Checks properties are as originally set

            state = State.Initialise;

            // Create Meta and set default properties
            FtMeta meta = new FtMeta();

            defaultMetaProperties.LoadIntoMeta(ref meta);

            FtStringMetaField stringField = meta.FieldList.New(FtStandardDataType.String) as FtStringMetaField;

            stringField.Name = StringFieldName;
            FtBooleanMetaField booleanField = meta.FieldList.New(FtStandardDataType.Boolean) as FtBooleanMetaField;

            booleanField.Name = BooleanFieldName;
            FtIntegerMetaField integerField = meta.FieldList.New(FtStandardDataType.Integer) as FtIntegerMetaField;

            integerField.Name = IntegerFieldName;
            FtFloatMetaField floatField = meta.FieldList.New(FtStandardDataType.Float) as FtFloatMetaField;

            floatField.Name = FloatFieldName;
            FtDecimalMetaField decimalField = meta.FieldList.New(FtStandardDataType.Decimal) as FtDecimalMetaField;

            decimalField.Name = DecimalFieldName;
            FtDateTimeMetaField dateTimeField = meta.FieldList.New(FtStandardDataType.DateTime) as FtDateTimeMetaField;

            dateTimeField.Name = DateTimeFieldName;

            FtStringMetaField redirectStringField1 = meta.FieldList.New(FtStandardDataType.String) as FtStringMetaField;

            redirectStringField1.Name = RedirectStringField1Name;
            FtBooleanMetaField redirectBooleanField2 = meta.FieldList.New(FtStandardDataType.Boolean) as FtBooleanMetaField;

            redirectBooleanField2.Name = RedirectBooleanField2Name;
            FtIntegerMetaField redirectIntegerField3 = meta.FieldList.New(FtStandardDataType.Integer) as FtIntegerMetaField;

            redirectIntegerField3.Name = RedirectIntegerField3Name;
            FtFloatMetaField redirectFloatField4 = meta.FieldList.New(FtStandardDataType.Float) as FtFloatMetaField;

            redirectFloatField4.Name = RedirectFloatField4Name;
            FtDecimalMetaField redirectDecimalField5 = meta.FieldList.New(FtStandardDataType.Decimal) as FtDecimalMetaField;

            redirectDecimalField5.Name = RedirectDecimalField5Name;
            FtDateTimeMetaField redirectDateTimeField6 = meta.FieldList.New(FtStandardDataType.DateTime) as FtDateTimeMetaField;

            redirectDateTimeField6.Name = RedirectDateTimeField6Name;

            // Create root sequence
            FtMetaSequence rootSequence = meta.SequenceList.New();

            rootSequence.Name = "Root";
            rootSequence.Root = true;

            // Create redirect target sequence
            FtMetaSequence redirectTargetSequence = meta.SequenceList.New();

            redirectTargetSequence.Name = "RedirectTarget";
            FtMetaSequenceItem     sequenceItem;
            FtMetaSequenceRedirect sequenceRedirect;

            sequenceItem              = redirectTargetSequence.ItemList.New();
            sequenceItem.Field        = redirectStringField1;
            sequenceItem              = redirectTargetSequence.ItemList.New();
            sequenceItem.Field        = redirectBooleanField2;
            sequenceRedirect          = sequenceItem.RedirectList.New(FtStandardSequenceRedirectType.Null);
            sequenceRedirect.Sequence = rootSequence;
            sequenceItem              = redirectTargetSequence.ItemList.New();
            sequenceItem.Field        = redirectIntegerField3;
            sequenceItem              = redirectTargetSequence.ItemList.New();
            sequenceItem.Field        = redirectFloatField4;
            sequenceRedirect          = sequenceItem.RedirectList.New(FtStandardSequenceRedirectType.Null);
            sequenceRedirect.Sequence = rootSequence;
            sequenceItem              = redirectTargetSequence.ItemList.New();
            sequenceItem.Field        = redirectDecimalField5;
            sequenceItem              = redirectTargetSequence.ItemList.New();
            sequenceItem.Field        = redirectDateTimeField6;

            // Create one field of each type and set properties to defaults and put in sequence.  Add default redirect to sequence item redirect list
            AllDefaults_Field(stringField, rootSequence, redirectTargetSequence, FtStandardSequenceRedirectType.ExactString, 0);
            AllDefaults_Field(booleanField, rootSequence, redirectTargetSequence, FtStandardSequenceRedirectType.Boolean, 1);
            booleanField.FalseText = BooleanFalseText;
            booleanField.TrueText  = BooleanTrueText;
            booleanField.Styles    = BooleanStyles;
            AllDefaults_Field(integerField, rootSequence, redirectTargetSequence, FtStandardSequenceRedirectType.ExactInteger, 2);
            integerField.Format = IntegerFieldFormat;
            integerField.Styles = IntegerFieldStyles;
            AllDefaults_Field(floatField, rootSequence, redirectTargetSequence, FtStandardSequenceRedirectType.ExactFloat, 3);
            floatField.Format = FloatFieldFormat;
            floatField.Styles = FloatFieldStyles;
            AllDefaults_Field(decimalField, rootSequence, redirectTargetSequence, FtStandardSequenceRedirectType.ExactDecimal, 4);
            decimalField.Format = DecimalFieldFormat;
            decimalField.Styles = DecimalFieldStyles;
            AllDefaults_Field(dateTimeField, rootSequence, redirectTargetSequence, FtStandardSequenceRedirectType.ExactDateTime, 5);
            dateTimeField.Format = DateTimeFieldFormat;
            dateTimeField.Styles = DateTimeFieldStyles;

            // Add one substitution of default substitution type
            FtMetaSubstitution substitution = meta.SubstitutionList.New();

            substitution.Type  = SubstitutionType;
            substitution.Token = SubstitutionToken;
            substitution.Value = SubstitutionValue;

            // Serialize Meta
            XmlWriter writer = XmlWriter.Create(filePath, xmlWriterSettings);

            FtMetaSerializer.Serialize(meta, writer);
            writer.Close();

            state = State.Assert;

            string DataFilePath = Path.Combine(DataFolder, AllDefaultsFileName);

            if (!TextFilesAreEqual(filePath, DataFilePath))
            {
                Assert.Fail("AllDefaults does not match Test Data");
            }
            else
            {
                FtMeta deserialisedMeta = FtMetaSerializer.Deserialize(filePath);

                defaultMetaProperties.AssertMetaAreEqual(meta);

                rootSequence = meta.SequenceList[0];
                Assert.AreEqual <bool>(true, rootSequence.Root);
                Assert.AreEqual <int>(6, rootSequence.ItemList.Count);
                redirectTargetSequence = meta.SequenceList[1];
                Assert.AreEqual <bool>(false, redirectTargetSequence.Root);
                Assert.AreEqual <int>(6, redirectTargetSequence.ItemList.Count);

                stringField = meta.FieldList[0] as FtStringMetaField;
                Assert.AreEqual <string>(StringFieldName, stringField.Name);
                AllDefaults_Field(stringField, rootSequence, redirectTargetSequence, FtStandardSequenceRedirectType.ExactString, 0);
                booleanField = meta.FieldList[1] as FtBooleanMetaField;
                Assert.AreEqual <string>(BooleanFieldName, booleanField.Name);
                AllDefaults_Field(booleanField, rootSequence, redirectTargetSequence, FtStandardSequenceRedirectType.Boolean, 1);
                Assert.AreEqual <string>(BooleanFalseText, booleanField.FalseText);
                Assert.AreEqual <string>(BooleanTrueText, booleanField.TrueText);
                Assert.AreEqual <FtBooleanStyles>(BooleanStyles, booleanField.Styles);
                integerField = meta.FieldList[2] as FtIntegerMetaField;
                Assert.AreEqual <string>(IntegerFieldName, integerField.Name);
                AllDefaults_Field(integerField, rootSequence, redirectTargetSequence, FtStandardSequenceRedirectType.ExactInteger, 2);
                Assert.AreEqual <string>(IntegerFieldFormat, integerField.Format);
                Assert.AreEqual <NumberStyles>(IntegerFieldStyles, integerField.Styles);
                floatField = meta.FieldList[3] as FtFloatMetaField;
                Assert.AreEqual <string>(FloatFieldName, floatField.Name);
                AllDefaults_Field(floatField, rootSequence, redirectTargetSequence, FtStandardSequenceRedirectType.ExactFloat, 3);
                Assert.AreEqual <string>(FloatFieldFormat, floatField.Format);
                Assert.AreEqual <NumberStyles>(FloatFieldStyles, floatField.Styles);
                decimalField = meta.FieldList[4] as FtDecimalMetaField;
                Assert.AreEqual <string>(DecimalFieldName, decimalField.Name);
                AllDefaults_Field(decimalField, rootSequence, redirectTargetSequence, FtStandardSequenceRedirectType.ExactDecimal, 4);
                Assert.AreEqual <string>(DecimalFieldFormat, decimalField.Format);
                Assert.AreEqual <NumberStyles>(DecimalFieldStyles, decimalField.Styles);
                dateTimeField = meta.FieldList[5] as FtDateTimeMetaField;
                Assert.AreEqual <string>(DateTimeFieldName, dateTimeField.Name);
                AllDefaults_Field(dateTimeField, rootSequence, redirectTargetSequence, FtStandardSequenceRedirectType.ExactDateTime, 5);
                Assert.AreEqual <string>(DateTimeFieldFormat, dateTimeField.Format);
                Assert.AreEqual <DateTimeStyles>(DateTimeFieldStyles, dateTimeField.Styles);

                redirectStringField1 = meta.FieldList[6] as FtStringMetaField;
                Assert.AreEqual <string>(RedirectStringField1Name, redirectStringField1.Name);
                redirectBooleanField2 = meta.FieldList[7] as FtBooleanMetaField;
                Assert.AreEqual <string>(RedirectBooleanField2Name, redirectBooleanField2.Name);
                Assert.AreEqual <string>(BooleanFalseText, redirectBooleanField2.FalseText);
                Assert.AreEqual <string>(BooleanTrueText, redirectBooleanField2.TrueText);
                Assert.AreEqual <FtBooleanStyles>(BooleanStyles, redirectBooleanField2.Styles);
                redirectIntegerField3 = meta.FieldList[8] as FtIntegerMetaField;
                Assert.AreEqual <string>(RedirectIntegerField3Name, redirectIntegerField3.Name);
                Assert.AreEqual <string>(IntegerFieldFormat, redirectIntegerField3.Format);
                Assert.AreEqual <NumberStyles>(IntegerFieldStyles, redirectIntegerField3.Styles);
                redirectFloatField4 = meta.FieldList[9] as FtFloatMetaField;
                Assert.AreEqual <string>(RedirectFloatField4Name, redirectFloatField4.Name);
                Assert.AreEqual <string>(FloatFieldFormat, redirectFloatField4.Format);
                Assert.AreEqual <NumberStyles>(FloatFieldStyles, redirectFloatField4.Styles);
                redirectDecimalField5 = meta.FieldList[10] as FtDecimalMetaField;
                Assert.AreEqual <string>(RedirectDecimalField5Name, redirectDecimalField5.Name);
                Assert.AreEqual <string>(DecimalFieldFormat, redirectDecimalField5.Format);
                Assert.AreEqual <NumberStyles>(DecimalFieldStyles, redirectDecimalField5.Styles);
                redirectDateTimeField6 = meta.FieldList[11] as FtDateTimeMetaField;
                Assert.AreEqual <string>(RedirectDateTimeField6Name, redirectDateTimeField6.Name);
                Assert.AreEqual <string>(DateTimeFieldFormat, redirectDateTimeField6.Format);
                Assert.AreEqual <DateTimeStyles>(DateTimeFieldStyles, redirectDateTimeField6.Styles);

                Assert.AreEqual <FtMetaField>(redirectStringField1, redirectTargetSequence.ItemList[0].Field);
                Assert.AreEqual <int>(0, redirectTargetSequence.ItemList[0].RedirectList.Count);
                Assert.AreEqual <FtMetaField>(redirectBooleanField2, redirectTargetSequence.ItemList[1].Field);
                Assert.AreEqual <int>(1, redirectTargetSequence.ItemList[1].RedirectList.Count);
                Assert.AreEqual <int>(FtStandardSequenceRedirectType.Null, redirectTargetSequence.ItemList[1].RedirectList[0].Type);
                Assert.AreEqual <FtMetaField>(redirectIntegerField3, redirectTargetSequence.ItemList[2].Field);
                Assert.AreEqual <int>(0, redirectTargetSequence.ItemList[2].RedirectList.Count);
                Assert.AreEqual <FtMetaField>(redirectFloatField4, redirectTargetSequence.ItemList[3].Field);
                Assert.AreEqual <int>(1, redirectTargetSequence.ItemList[3].RedirectList.Count);
                Assert.AreEqual <int>(FtStandardSequenceRedirectType.Null, redirectTargetSequence.ItemList[3].RedirectList[0].Type);
                Assert.AreEqual <FtMetaField>(redirectDecimalField5, redirectTargetSequence.ItemList[4].Field);
                Assert.AreEqual <int>(0, redirectTargetSequence.ItemList[4].RedirectList.Count);
                Assert.AreEqual <FtMetaField>(redirectDateTimeField6, redirectTargetSequence.ItemList[5].Field);
                Assert.AreEqual <int>(0, redirectTargetSequence.ItemList[5].RedirectList.Count);
            }
        }