internal void AssertMetaFieldAreEqual(FtMetaField field, bool includeName) { if (includeName) { Assert.AreEqual <string>(Name, field.Name); } Assert.AreEqual <int>(Id, field.Id); Assert.AreEqual <bool>(FixedWidth, field.FixedWidth); Assert.AreEqual <int>(Width, field.Width); Assert.AreEqual <bool>(Constant, field.Constant); Assert.AreEqual <bool>(Null, field.Null); Assert.AreEqual <FtQuotedType>(ValueQuotedType, field.ValueQuotedType); Assert.AreEqual <bool>(ValueAlwaysWriteOptionalQuote, field.ValueAlwaysWriteOptionalQuote); Assert.AreEqual <bool>(ValueWritePrefixSpace, field.ValueWritePrefixSpace); Assert.AreEqual <FtPadAlignment>(ValuePadAlignment, field.ValuePadAlignment); Assert.AreEqual <FtPadCharType>(ValuePadCharType, field.ValuePadCharType); Assert.AreEqual <char>(ValuePadChar, field.ValuePadChar); Assert.AreEqual <FtTruncateType>(ValueTruncateType, field.ValueTruncateType); Assert.AreEqual <char>(ValueTruncateChar, field.ValueTruncateChar); Assert.AreEqual <char>(ValueEndOfValueChar, field.ValueEndOfValueChar); Assert.AreEqual <char>(ValueNullChar, field.ValueNullChar); Assert.AreEqual <FtHeadingConstraint>(HeadingConstraint, field.HeadingConstraint); Assert.AreEqual <FtQuotedType>(HeadingQuotedType, field.HeadingQuotedType); Assert.AreEqual <bool>(HeadingAlwaysWriteOptionalQuote, field.HeadingAlwaysWriteOptionalQuote); Assert.AreEqual <bool>(HeadingWritePrefixSpace, field.HeadingWritePrefixSpace); Assert.AreEqual <FtPadAlignment>(HeadingPadAlignment, field.HeadingPadAlignment); Assert.AreEqual <FtPadCharType>(HeadingPadCharType, field.HeadingPadCharType); Assert.AreEqual <char>(HeadingPadChar, field.HeadingPadChar); Assert.AreEqual <FtTruncateType>(HeadingTruncateType, field.HeadingTruncateType); Assert.AreEqual <char>(HeadingTruncateChar, field.HeadingTruncateChar); Assert.AreEqual <char>(HeadingEndOfValueChar, field.HeadingEndOfValueChar); }
internal void LoadIntoMetaField(ref FtMetaField field, bool includeName) { if (includeName) { field.Name = Name; } field.Id = Id; field.FixedWidth = FixedWidth; field.Width = Width; field.Constant = Constant; field.Null = Null; field.ValueQuotedType = ValueQuotedType; field.ValueAlwaysWriteOptionalQuote = ValueAlwaysWriteOptionalQuote; field.ValueWritePrefixSpace = ValueWritePrefixSpace; field.ValuePadAlignment = ValuePadAlignment; field.ValuePadCharType = ValuePadCharType; field.ValuePadChar = ValuePadChar; field.ValueTruncateType = ValueTruncateType; field.ValueTruncateChar = ValueTruncateChar; field.ValueEndOfValueChar = ValueEndOfValueChar; field.ValueNullChar = ValueNullChar; field.HeadingConstraint = HeadingConstraint; field.HeadingQuotedType = HeadingQuotedType; field.HeadingAlwaysWriteOptionalQuote = HeadingAlwaysWriteOptionalQuote; field.HeadingWritePrefixSpace = HeadingWritePrefixSpace; field.HeadingPadAlignment = HeadingPadAlignment; field.HeadingPadCharType = HeadingPadCharType; field.HeadingPadChar = HeadingPadChar; field.HeadingTruncateType = HeadingTruncateType; field.HeadingTruncateChar = HeadingTruncateChar; field.HeadingEndOfValueChar = HeadingEndOfValueChar; }
private void AllDefaults_Field(FtMetaField field, FtMetaSequence sequence, FtMetaSequence targetSequence, int redirectType, int itemIdx) { const FtSequenceInvokationDelay SequenceInvokationDelay = FtSequenceInvokationDelay.ftikAfterField; if (state == State.Initialise) { defaultMetaFieldProperties.LoadIntoMetaField(ref field, false); FtMetaSequenceItem sequenceItem = sequence.ItemList.New(); sequenceItem.Field = field; FtMetaSequenceRedirect sequenceRedirect = sequenceItem.RedirectList.New(redirectType); sequenceRedirect.InvokationDelay = SequenceInvokationDelay; sequenceRedirect.Sequence = targetSequence; } else { defaultMetaFieldProperties.AssertMetaFieldAreEqual(field, false); FtMetaSequenceItem sequenceItem = sequence.ItemList[itemIdx]; Assert.AreEqual <FtMetaField>(field, sequenceItem.Field); FtMetaSequenceRedirect sequenceRedirect = sequenceItem.RedirectList[0]; Assert.AreEqual <FtSequenceInvokationDelay>(SequenceInvokationDelay, sequenceRedirect.InvokationDelay); Assert.AreEqual <FtMetaSequence>(targetSequence, sequenceRedirect.Sequence); } }
protected internal override void Assign(FtMetaField source) { base.Assign(source); FtGenericMetaField <T> typedSource = source as FtGenericMetaField <T>; Value = typedSource.Value; }
internal void LoadDefaults(FtMetaField forHeadingsField = null) { Id = DefaultId; FixedWidth = DefaultFixedWidth; Width = DefaultWidth; Constant = DefaultConstant; Null = DefaultNull; ValueQuotedType = DefaultValueQuotedType; ValueAlwaysWriteOptionalQuote = DefaultValueAlwaysWriteOptionalQuote; ValueWritePrefixSpace = DefaultValueWritePrefixSpace; ValuePadAlignment = DefaultValuePadAlignment; ValuePadCharType = DefaultValuePadCharType; ValuePadChar = DefaultValuePadChar; ValueTruncateType = DefaultValueTruncateType; ValueTruncateChar = DefaultValueTruncateChar; ValueEndOfValueChar = DefaultValueEndOfValueChar; ValueNullChar = DefaultValueNullChar; if (forHeadingsField == null) { HeadingConstraint = DefaultHeadingConstraint; HeadingQuotedType = DefaultHeadingQuotedType; HeadingAlwaysWriteOptionalQuote = DefaultHeadingAlwaysWriteOptionalQuote; HeadingWritePrefixSpace = DefaultHeadingWritePrefixSpace; HeadingPadAlignment = DefaultHeadingPadAlignment; HeadingPadCharType = DefaultHeadingPadCharType; HeadingPadChar = DefaultHeadingPadChar; HeadingTruncateType = DefaultHeadingTruncateType; HeadingTruncateChar = DefaultHeadingTruncateChar; HeadingEndOfValueChar = DefaultHeadingEndOfValueChar; } else { HeadingConstraint = forHeadingsField.DefaultHeadingConstraint; HeadingQuotedType = forHeadingsField.DefaultHeadingQuotedType; HeadingAlwaysWriteOptionalQuote = forHeadingsField.DefaultHeadingAlwaysWriteOptionalQuote; HeadingWritePrefixSpace = forHeadingsField.DefaultHeadingWritePrefixSpace; HeadingPadAlignment = forHeadingsField.DefaultHeadingPadAlignment; HeadingPadCharType = forHeadingsField.DefaultHeadingPadCharType; HeadingPadChar = forHeadingsField.DefaultHeadingPadChar; HeadingTruncateType = forHeadingsField.DefaultHeadingTruncateType; HeadingTruncateChar = forHeadingsField.DefaultHeadingTruncateChar; HeadingEndOfValueChar = forHeadingsField.DefaultHeadingEndOfValueChar; } }
protected virtual bool ResolveFields(FtMeta meta, out string errorDescription) { FieldSorter.Rec[] sorterRecArray = new FieldSorter.Rec[fieldList.Count]; FieldReadElement[] sortedElements; for (int i = 0; i < fieldList.Count; i++) { FieldReadElement element = fieldList[i]; sorterRecArray[i].Target = element; sorterRecArray[i].Implicit = i; sorterRecArray[i].Explicit = element.ExplicitIndex; } int duplicateExplicitIndex; if (!FieldSorter.TrySort(sorterRecArray, out sortedElements, out duplicateExplicitIndex)) { errorDescription = string.Format(Properties.Resources.FieldedTextReadElement_ResolveFields_DuplicateExplicitIndexInFields, duplicateExplicitIndex); return(false); } else { errorDescription = ""; bool result = true; for (int i = 0; i < sortedElements.Length; i++) { FieldReadElement element = sortedElements[i]; FtMetaField field = meta.FieldList.New(element.DataType); if (!element.ResolveTo(field, out errorDescription)) { result = false; break; } } return(result); } }
// This program programmatically generates a Meta file that uses sequences. // The Meta is for a CSV file which lists 3 types of pets. For each pet the file will specify // its type and its name. These 2 fields make the root sequence. // Pet type 1 is cats. For each cat it will specify its running speed (Cat Sequence) // Pet type 2 is dogs. For each dog it will specify its walking distance, its running speed // and whether it is being trained. (Dog Sequence) // If a dog is being trained, it will also specify the trainer and the cost of each // training session. (Training Sequence) // Pet type 3 is gold fish. For each gold fish, it will specify its color and // chinese classification (GoldFish sequence). static void Main(string[] args) { const string MetaFileName = "ExampleSequenceMeta.ftm"; // Define Field Names const string TypeFieldName = "Type"; const string NameFieldName = "Name"; const string RunningSpeedFieldName = "RunningSpeed"; const string WalkDistanceFieldName = "WalkDistance"; const string TrainingFieldName = "Training"; const string TrainerFieldName = "Trainer"; const string SessionCostFieldName = "SessionCost"; const string ColorFieldName = "Color"; const string ChineseClassificationFieldName = "ChineseClassification"; // Define Field Ids const int TypeFieldId = 0; const int NameFieldId = 1; const int RunningSpeedFieldId = 2; const int WalkDistanceFieldId = 3; const int TrainingFieldId = 4; const int TrainerFieldId = 5; const int SessionCostFieldId = 6; const int ColorFieldId = 7; const int ChineseClassificationFieldId = 8; // Define Sequence Names const string RootSequenceName = "Root"; const string CatSequenceName = "Cat"; const string DogSequenceName = "Dog"; const string GoldFishSequenceName = "GoldFish"; const string TrainingSequenceName = "Training"; FtMeta meta = new FtMeta(); // Add fields to Meta FtMetaField typeField = meta.FieldList.New(FtStandardDataType.Integer); typeField.Name = TypeFieldName; typeField.Id = TypeFieldId; FtMetaField nameField = meta.FieldList.New(FtStandardDataType.String); nameField.Name = NameFieldName; nameField.Id = NameFieldId; FtMetaField runningSpeedField = meta.FieldList.New(FtStandardDataType.Float); runningSpeedField.Name = RunningSpeedFieldName; runningSpeedField.Id = RunningSpeedFieldId; FtMetaField walkDistanceField = meta.FieldList.New(FtStandardDataType.Float); walkDistanceField.Name = WalkDistanceFieldName; walkDistanceField.Id = WalkDistanceFieldId; FtMetaField trainingField = meta.FieldList.New(FtStandardDataType.Boolean); trainingField.Name = TrainingFieldName; trainingField.Id = TrainingFieldId; FtMetaField trainerField = meta.FieldList.New(FtStandardDataType.String); trainerField.Name = TrainerFieldName; trainerField.Id = TrainerFieldId; FtMetaField sessionCostField = meta.FieldList.New(FtStandardDataType.Decimal); sessionCostField.Name = SessionCostFieldName; sessionCostField.Id = SessionCostFieldId; FtMetaField tankLocationField = meta.FieldList.New(FtStandardDataType.String); tankLocationField.Name = ColorFieldName; tankLocationField.Id = ColorFieldId; FtMetaField chineseClassificationField = meta.FieldList.New(FtStandardDataType.String); chineseClassificationField.Name = ChineseClassificationFieldName; chineseClassificationField.Id = ChineseClassificationFieldId; // Add Sequences to Meta FtMetaSequence rootSequence = meta.SequenceList.New(); rootSequence.Name = RootSequenceName; rootSequence.Root = true; FtMetaSequence catSequence = meta.SequenceList.New(); catSequence.Name = CatSequenceName; FtMetaSequence dogSequence = meta.SequenceList.New(); dogSequence.Name = DogSequenceName; FtMetaSequence goldFishSequence = meta.SequenceList.New(); goldFishSequence.Name = GoldFishSequenceName; FtMetaSequence trainingSequence = meta.SequenceList.New(); trainingSequence.Name = TrainingSequenceName; // Add SequenceItems to Sequences. // Add SequenceItems with fields in correct order. This way index does not need to be specified FtMetaSequenceItem item; // used for sequence items without redirects FtMetaSequenceItem typeSequenceItem = rootSequence.ItemList.New(); typeSequenceItem.Field = typeField; item = rootSequence.ItemList.New(); item.Field = nameField; item = catSequence.ItemList.New(); item.Field = runningSpeedField; item = dogSequence.ItemList.New(); item.Field = walkDistanceField; item = dogSequence.ItemList.New(); item.Field = runningSpeedField; FtMetaSequenceItem trainingSequenceItem = dogSequence.ItemList.New(); trainingSequenceItem.Field = trainingField; item = trainingSequence.ItemList.New(); item.Field = trainerField; item = trainingSequence.ItemList.New(); item.Field = sessionCostField; item = goldFishSequence.ItemList.New(); item.Field = tankLocationField; item = goldFishSequence.ItemList.New(); item.Field = chineseClassificationField; // Add redirects to Meta Sequence Items. FtExactIntegerMetaSequenceRedirect typeRedirect; typeRedirect = typeSequenceItem.RedirectList.New(FtStandardSequenceRedirectType.ExactInteger) as FtExactIntegerMetaSequenceRedirect; typeRedirect.InvokationDelay = FtSequenceInvokationDelay.ftikAfterSequence; typeRedirect.Sequence = catSequence; typeRedirect.Value = 1; typeRedirect = typeSequenceItem.RedirectList.New(FtStandardSequenceRedirectType.ExactInteger) as FtExactIntegerMetaSequenceRedirect; typeRedirect.InvokationDelay = FtSequenceInvokationDelay.ftikAfterSequence; typeRedirect.Sequence = dogSequence; typeRedirect.Value = 2; typeRedirect = typeSequenceItem.RedirectList.New(FtStandardSequenceRedirectType.ExactInteger) as FtExactIntegerMetaSequenceRedirect; typeRedirect.InvokationDelay = FtSequenceInvokationDelay.ftikAfterSequence; typeRedirect.Sequence = goldFishSequence; typeRedirect.Value = 3; FtBooleanMetaSequenceRedirect trainingRedirect; trainingRedirect = trainingSequenceItem.RedirectList.New(FtStandardSequenceRedirectType.Boolean) as FtBooleanMetaSequenceRedirect; trainingRedirect.InvokationDelay = FtSequenceInvokationDelay.ftikAfterField; trainingRedirect.Sequence = trainingSequence; trainingRedirect.Value = true; // Save Meta to file System.Xml.XmlWriterSettings writerSettings = new System.Xml.XmlWriterSettings(); writerSettings.Indent = true; writerSettings.IndentChars = " "; FtMetaSerializer.Serialize(meta, MetaFileName, writerSettings); }
public void MetaSequence() { FtMeta meta = new FtMeta(); FtMetaField rootField1 = meta.FieldList.New(FtStandardDataType.String); rootField1.Id = RootField1Id; FtMetaField rootField2 = meta.FieldList.New(FtStandardDataType.Integer); rootField2.Id = RootField2Id; FtMetaField rootField3 = meta.FieldList.New(FtStandardDataType.Boolean); rootField3.Id = RootField3Id; FtMetaField sequence1Field1 = meta.FieldList.New(FtStandardDataType.Float); sequence1Field1.Id = Sequence1Field1Id; FtMetaField sequence1Field2 = meta.FieldList.New(FtStandardDataType.Decimal); sequence1Field2.Id = Sequence1Field2Id; FtMetaField sequence2Field1 = meta.FieldList.New(FtStandardDataType.DateTime); sequence2Field1.Id = Sequence2Field1Id; FtMetaField sequence2Field2 = meta.FieldList.New(FtStandardDataType.Boolean); sequence2Field2.Id = Sequence2Field2Id; FtMetaField sequence2Field3 = meta.FieldList.New(FtStandardDataType.String); sequence2Field3.Id = Sequence2Field3Id; FtMetaField sequence2Field4 = meta.FieldList.New(FtStandardDataType.Integer); sequence2Field4.Id = Sequence2Field4Id; FtMetaField sequence3Field1 = meta.FieldList.New(FtStandardDataType.Boolean); sequence3Field1.Id = Sequence3Field1Id; FtMetaField sequence4Field1 = meta.FieldList.New(FtStandardDataType.Float); sequence4Field1.Id = Sequence4Field1Id; FtMetaField sequence4Field2 = meta.FieldList.New(FtStandardDataType.Decimal); sequence4Field2.Id = Sequence4Field2Id; FtMetaSequence rootSequence = meta.SequenceList.New(); rootSequence.Root = true; FtMetaSequenceItem rootItem1 = rootSequence.ItemList.New(); rootItem1.Field = rootField1; FtMetaSequenceItem rootItem2 = rootSequence.ItemList.New(); rootItem2.Field = rootField2; FtMetaSequenceItem rootItem3 = rootSequence.ItemList.New(); rootItem3.Field = rootField3; FtMetaSequence sequence1 = meta.SequenceList.New(); sequence1.Name = Sequence1Name; FtMetaSequenceItem sequence1Item1 = sequence1.ItemList.New(); sequence1Item1.Field = sequence1Field1; FtMetaSequenceItem sequence1Item2 = sequence1.ItemList.New(); sequence1Item2.Field = sequence1Field2; FtMetaSequence sequence2 = meta.SequenceList.New(); sequence2.Name = Sequence2Name; FtMetaSequenceItem sequence2Item1 = sequence2.ItemList.New(); sequence2Item1.Field = sequence2Field1; FtMetaSequenceItem sequence2Item2 = sequence2.ItemList.New(); sequence2Item2.Field = sequence2Field2; FtMetaSequenceItem sequence2Item3 = sequence2.ItemList.New(); sequence2Item3.Field = sequence2Field3; FtMetaSequenceItem sequence2Item4 = sequence2.ItemList.New(); sequence2Item4.Field = sequence2Field4; FtMetaSequence sequence3 = meta.SequenceList.New(); sequence3.Name = Sequence3Name; FtMetaSequenceItem sequence3Item1 = sequence3.ItemList.New(); sequence3Item1.Field = sequence3Field1; FtMetaSequence sequence4 = meta.SequenceList.New(); sequence4.Name = Sequence4Name; FtMetaSequenceItem sequence4Item1 = sequence4.ItemList.New(); sequence4Item1.Field = sequence4Field1; FtMetaSequenceItem sequence4Item2 = sequence4.ItemList.New(); sequence4Item2.Field = sequence4Field2; FtExactIntegerMetaSequenceRedirect rootRedirect1 = rootItem2.RedirectList.New(FtStandardSequenceRedirectType.ExactInteger) as FtExactIntegerMetaSequenceRedirect; rootRedirect1.InvokationDelay = RootRedirect1InvokationDelay; rootRedirect1.Value = RootRedirect1Value; rootRedirect1.Sequence = sequence1; FtExactIntegerMetaSequenceRedirect rootRedirect2 = rootItem2.RedirectList.New(FtStandardSequenceRedirectType.ExactInteger) as FtExactIntegerMetaSequenceRedirect; rootRedirect2.InvokationDelay = RootRedirect2InvokationDelay; rootRedirect2.Value = 2; rootRedirect2.Sequence = sequence2; FtExactIntegerMetaSequenceRedirect rootRedirect3 = rootItem2.RedirectList.New(FtStandardSequenceRedirectType.ExactInteger) as FtExactIntegerMetaSequenceRedirect; rootRedirect3.InvokationDelay = RootRedirect3InvokationDelay; rootRedirect3.Value = 3; rootRedirect3.Sequence = sequence3; FtNullMetaSequenceRedirect sequence1Redirect1 = sequence1Item2.RedirectList.New(FtStandardSequenceRedirectType.Null) as FtNullMetaSequenceRedirect; sequence1Redirect1.InvokationDelay = Sequence1Redirect1InvokationDelay; sequence1Redirect1.Sequence = sequence4; FtCaseInsensitiveStringMetaSequenceRedirect sequence2Redirect1 = sequence2Item3.RedirectList.New(FtStandardSequenceRedirectType.CaseInsensitiveString) as FtCaseInsensitiveStringMetaSequenceRedirect; sequence2Redirect1.InvokationDelay = Sequence2Redirect1InvokationDelay; sequence2Redirect1.Value = Sequence2Redirect1Value; sequence2Redirect1.Sequence = sequence4; // Serialize Meta XmlWriter writer = XmlWriter.Create(filePath, xmlWriterSettings); FtMetaSerializer.Serialize(meta, writer); writer.Close(); string DataFilePath = Path.Combine(DataFolder, SequenceFileName); if (!TextFilesAreEqual(filePath, DataFilePath)) { Assert.Fail("MetaSequence does not match Test Data"); } else { FtMeta deserializedMeta = FtMetaSerializer.Deserialize(filePath); AssertDeserializedMeta(deserializedMeta); string foreignFilePath = Path.Combine(DataFolder, ForeignFileName); FtMeta deserializedForeign = FtMetaSerializer.Deserialize(foreignFilePath); AssertDeserializedMeta(deserializedForeign); } }
private void AssertDeserializedMeta(FtMeta meta) { Assert.AreEqual <int>(12, meta.FieldList.Count); for (int i = 0; i < 12; i++) { Assert.AreEqual <int>(i, meta.FieldList[i].Id); } FtMetaField rootField1 = meta.FieldList[0]; Assert.AreEqual <int>(FtStandardDataType.String, rootField1.DataType); FtMetaField rootField2 = meta.FieldList[1]; Assert.AreEqual <int>(FtStandardDataType.Integer, rootField2.DataType); FtMetaField rootField3 = meta.FieldList[2]; Assert.AreEqual <int>(FtStandardDataType.Boolean, rootField3.DataType); FtMetaField sequence1Field1 = meta.FieldList[3]; Assert.AreEqual <int>(FtStandardDataType.Float, sequence1Field1.DataType); FtMetaField sequence1Field2 = meta.FieldList[4]; Assert.AreEqual <int>(FtStandardDataType.Decimal, sequence1Field2.DataType); FtMetaField sequence2Field1 = meta.FieldList[5]; Assert.AreEqual <int>(FtStandardDataType.DateTime, sequence2Field1.DataType); FtMetaField sequence2Field2 = meta.FieldList[6]; Assert.AreEqual <int>(FtStandardDataType.Boolean, sequence2Field2.DataType); FtMetaField sequence2Field3 = meta.FieldList[7]; Assert.AreEqual <int>(FtStandardDataType.String, sequence2Field3.DataType); FtMetaField sequence2Field4 = meta.FieldList[8]; Assert.AreEqual <int>(FtStandardDataType.Integer, sequence2Field4.DataType); FtMetaField sequence3Field1 = meta.FieldList[9]; Assert.AreEqual <int>(FtStandardDataType.Boolean, sequence3Field1.DataType); FtMetaField sequence4Field1 = meta.FieldList[10]; Assert.AreEqual <int>(FtStandardDataType.Float, sequence4Field1.DataType); FtMetaField sequence4Field2 = meta.FieldList[11]; Assert.AreEqual <int>(FtStandardDataType.Decimal, sequence4Field2.DataType); Assert.AreEqual <int>(5, meta.SequenceList.Count); FtMetaSequence rootSequence = meta.SequenceList[0]; Assert.AreEqual <bool>(true, rootSequence.Root); Assert.AreEqual <string>(RootSequenceName, rootSequence.Name); Assert.AreEqual <int>(3, rootSequence.ItemList.Count); FtMetaSequence sequence1 = meta.SequenceList[1]; Assert.AreEqual <bool>(false, sequence1.Root); Assert.AreEqual <string>(Sequence1Name, sequence1.Name); Assert.AreEqual <int>(2, sequence1.ItemList.Count); FtMetaSequence sequence2 = meta.SequenceList[2]; Assert.AreEqual <bool>(false, sequence2.Root); Assert.AreEqual <string>(Sequence2Name, sequence2.Name); Assert.AreEqual <int>(4, sequence2.ItemList.Count); FtMetaSequence sequence3 = meta.SequenceList[3]; Assert.AreEqual <bool>(false, sequence3.Root); Assert.AreEqual <string>(Sequence3Name, sequence3.Name); Assert.AreEqual <int>(1, sequence3.ItemList.Count); FtMetaSequence sequence4 = meta.SequenceList[4]; Assert.AreEqual <bool>(false, sequence4.Root); Assert.AreEqual <string>(Sequence4Name, sequence4.Name); Assert.AreEqual <int>(2, sequence4.ItemList.Count); Assert.AreEqual <FtMetaField>(rootSequence.ItemList[0].Field, rootField1); FtMetaSequenceItem rootItem2 = rootSequence.ItemList[1]; Assert.AreEqual <FtMetaField>(rootItem2.Field, rootField2); Assert.AreEqual <FtMetaField>(rootSequence.ItemList[2].Field, rootField3); Assert.AreEqual <FtMetaField>(sequence1.ItemList[0].Field, sequence1Field1); FtMetaSequenceItem sequence1Item2 = sequence1.ItemList[1]; Assert.AreEqual <FtMetaField>(sequence1Item2.Field, sequence1Field2); Assert.AreEqual <FtMetaField>(sequence2.ItemList[0].Field, sequence2Field1); Assert.AreEqual <FtMetaField>(sequence2.ItemList[1].Field, sequence2Field2); FtMetaSequenceItem sequence2Item3 = sequence2.ItemList[2]; Assert.AreEqual <FtMetaField>(sequence2Item3.Field, sequence2Field3); Assert.AreEqual <FtMetaField>(sequence2.ItemList[3].Field, sequence2Field4); Assert.AreEqual <FtMetaField>(sequence3.ItemList[0].Field, sequence3Field1); Assert.AreEqual <FtMetaField>(sequence4.ItemList[0].Field, sequence4Field1); Assert.AreEqual <FtMetaField>(sequence4.ItemList[1].Field, sequence4Field2); FtExactIntegerMetaSequenceRedirect rootRedirect1 = rootItem2.RedirectList[0] as FtExactIntegerMetaSequenceRedirect; Assert.AreEqual <int>(FtStandardSequenceRedirectType.ExactInteger, ((FtMetaSequenceRedirect)rootRedirect1).Type); Assert.AreEqual <FtSequenceInvokationDelay>(RootRedirect1InvokationDelay, rootRedirect1.InvokationDelay); Assert.AreEqual <long>(RootRedirect1Value, rootRedirect1.Value); Assert.AreEqual <FtMetaSequence>(sequence1, rootRedirect1.Sequence); FtExactIntegerMetaSequenceRedirect rootRedirect2 = rootItem2.RedirectList[1] as FtExactIntegerMetaSequenceRedirect; Assert.AreEqual <int>(FtStandardSequenceRedirectType.ExactInteger, ((FtMetaSequenceRedirect)rootRedirect2).Type); Assert.AreEqual <FtSequenceInvokationDelay>(RootRedirect2InvokationDelay, rootRedirect2.InvokationDelay); Assert.AreEqual <long>(RootRedirect2Value, rootRedirect2.Value); Assert.AreEqual <FtMetaSequence>(sequence2, rootRedirect2.Sequence); FtExactIntegerMetaSequenceRedirect rootRedirect3 = rootItem2.RedirectList[2] as FtExactIntegerMetaSequenceRedirect; Assert.AreEqual <int>(FtStandardSequenceRedirectType.ExactInteger, ((FtMetaSequenceRedirect)rootRedirect3).Type); Assert.AreEqual <FtSequenceInvokationDelay>(RootRedirect3InvokationDelay, rootRedirect3.InvokationDelay); Assert.AreEqual <long>(RootRedirect3Value, rootRedirect3.Value); Assert.AreEqual <FtMetaSequence>(sequence3, rootRedirect3.Sequence); FtNullMetaSequenceRedirect sequence1Redirect1 = sequence1Item2.RedirectList[0] as FtNullMetaSequenceRedirect; Assert.AreEqual <int>(FtStandardSequenceRedirectType.Null, ((FtMetaSequenceRedirect)sequence1Redirect1).Type); Assert.AreEqual <FtSequenceInvokationDelay>(Sequence1Redirect1InvokationDelay, sequence1Redirect1.InvokationDelay); Assert.AreEqual <FtMetaSequence>(sequence4, sequence1Redirect1.Sequence); FtCaseInsensitiveStringMetaSequenceRedirect sequence2Redirect1 = sequence2Item3.RedirectList[0] as FtCaseInsensitiveStringMetaSequenceRedirect; Assert.AreEqual <int>(FtStandardSequenceRedirectType.CaseInsensitiveString, ((FtMetaSequenceRedirect)sequence2Redirect1).Type); Assert.AreEqual <FtSequenceInvokationDelay>(Sequence2Redirect1InvokationDelay, sequence2Redirect1.InvokationDelay); Assert.AreEqual <FtMetaSequence>(sequence4, sequence2Redirect1.Sequence); }
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; } } } } }