public void Ctor_Hierarchy_RecordIdentifierOnly()
{
var dff = new DelimitedFileFormat <Person>("X");
Assert.IsNotNull(dff);
Assert.AreEqual(',', dff.Delimiter);
Assert.AreEqual('"', dff.TextQualifier);
Assert.AreEqual(0, dff.HierarchyColumnIndex);
// FileFormat base configuration.
Assert.AreEqual(TextQualifierHandling.Strict, dff.TextQualifierHandling);
Assert.AreEqual(FileValidation.Unspecified, dff.FileValidation);
Assert.IsTrue(dff.IsHierarchical);
Assert.AreEqual(typeof(Person), dff.ContentRowType);
Assert.AreEqual("X", dff.ContentRecordIdentifier);
Assert.IsNull(dff.ContentValidator);
Assert.IsNull(dff.HeaderRowType);
Assert.IsNull(dff.HeaderRecordIdentifier);
Assert.IsNull(dff.HeaderValidator);
Assert.IsNull(dff.TrailerRowType);
Assert.IsNull(dff.TrailerRecordIdentifier);
Assert.IsNull(dff.TrailerValidator);
Assert.AreEqual(StringTransform.EmptyToNull, dff.StringTransform);
Assert.AreEqual(StringTrim.End, dff.StringTrim);
}
public void Write_Collection()
{
var sb = new StringBuilder();
using (var sw = new StringWriter(sb))
{
var ff = new DelimitedFileFormat <Data>(textQualifier: FileFormatBase.NoCharacter);
var fw = new FileWriter <Data>(sw, ff);
var results = fw.Write(new Data[] { new Data {
Col1 = "A"
}, new Data {
Col1 = "B"
} });
Assert.AreEqual(2, results.Length);
Assert.AreEqual(FileContentStatus.Content, results[0].Status);
Assert.IsFalse(results[0].HasErrors);
Assert.AreEqual(FileContentStatus.Content, results[1].Status);
Assert.IsFalse(results[1].HasErrors);
var result = fw.EndOfFile();
Assert.AreEqual(FileContentStatus.EndOfFile, result.Status);
Assert.IsFalse(result.HasErrors);
Assert.AreEqual("A,,\r\nB,,\r\n", sb.ToString());
}
}
public void Write_FileValidation_MustHaveAtLeastOneContentRow_WithTrailerRecord()
{
try
{
var sb = new StringBuilder();
using (var sw = new StringWriter(sb))
{
var ff = new DelimitedFileFormat <Data>();
var fw = new FileWriter <Data>(sw, ff);
ff.SetHeaderRowType <Header>();
ff.SetTrailerRowType <Trailer>();
ff.FileValidation = FileValidation.MustHaveAtLeastOneContentRow;
fw.WriteTrailer(new Trailer());
fw.EndOfFile();
}
}
catch (FileValidationException ex)
{
Assert.AreEqual(FileValidation.MustHaveAtLeastOneContentRow, ex.FileValidation);
Assert.AreEqual("The file must contain at least one content row.", ex.Message);
return;
}
Assert.Fail();
}
public void Write_FileValidation_MustHaveHeaderRow_WithContentNoHeader()
{
try
{
var sb = new StringBuilder();
using (var sw = new StringWriter(sb))
{
var ff = new DelimitedFileFormat <Data>();
var fw = new FileWriter <Data>(sw, ff);
ff.SetHeaderRowType <Header>();
ff.SetTrailerRowType <Trailer>();
ff.FileValidation = FileValidation.MustHaveHeaderRow;
fw.Write(new Data());
Assert.Fail();
}
}
catch (FileValidationException ex)
{
Assert.AreEqual(FileValidation.MustHaveHeaderRow, ex.FileValidation);
Assert.AreEqual("The first record must be identified as a Header row.", ex.Message);
return;
}
Assert.Fail();
}
public void Write_Hierarchy_Delimited()
{
var sb = new StringBuilder();
using (var sw = new StringWriter(sb))
{
var ff = new DelimitedFileFormat <HierarchyDataA>("A", 1, textQualifier: FileFormatBase.NoCharacter);
var fw = new FileWriter <HierarchyDataA>(sw, ff);
var result = fw.Write(CreateHierarchyA());
Assert.AreEqual(FileContentStatus.Content, result.Status);
Assert.IsFalse(result.HasErrors);
Assert.AreEqual(13, result.Records.Count);
AssertFileRecord(1, "A", 0, false, result.Records[0]);
AssertFileRecord(2, "B", 1, false, result.Records[1]);
AssertFileRecord(3, "C", 1, false, result.Records[2]);
AssertFileRecord(4, "D1", 2, false, result.Records[3]);
AssertFileRecord(5, "D1", 2, false, result.Records[4]);
AssertFileRecord(6, "D2", 2, false, result.Records[5]);
AssertFileRecord(7, "D2", 2, false, result.Records[6]);
AssertFileRecord(8, "D3", 2, false, result.Records[7]);
AssertFileRecord(9, "D3", 2, false, result.Records[8]);
AssertFileRecord(10, "E", 2, false, result.Records[9]);
AssertFileRecord(11, "F", 1, false, result.Records[10]);
AssertFileRecord(12, "G", 2, false, result.Records[11]);
AssertFileRecord(13, "H", 3, false, result.Records[12]);
result = fw.EndOfFile();
Assert.AreEqual(FileContentStatus.EndOfFile, result.Status);
Assert.IsFalse(result.HasErrors);
Assert.AreEqual("001,A\r\n002,B\r\n003,C\r\n004,D1\r\n005,D1\r\n006,D2\r\n007,D2\r\n008,D3\r\n009,D3\r\n010,E\r\n011,F\r\n012,G\r\n013,H\r\n", sb.ToString());
}
}
public void Ctor_Delimiter_Override()
{
var dff = new DelimitedFileFormat <Person>('x', 'y', PersonValidator.Default);
Assert.IsNotNull(dff);
Assert.AreEqual('x', dff.Delimiter);
Assert.AreEqual('y', dff.TextQualifier);
Assert.IsNull(dff.HierarchyColumnIndex);
Assert.AreEqual(TextQualifierHandling.Strict, dff.TextQualifierHandling);
// FileFormat base configuration.
Assert.AreEqual(FileValidation.Unspecified, dff.FileValidation);
Assert.IsFalse(dff.IsHierarchical);
Assert.AreEqual(typeof(Person), dff.ContentRowType);
Assert.IsNull(dff.ContentRecordIdentifier);
Assert.AreSame(PersonValidator.Default, dff.ContentValidator);
Assert.IsNull(dff.HeaderRowType);
Assert.IsNull(dff.HeaderRecordIdentifier);
Assert.IsNull(dff.HeaderValidator);
Assert.IsNull(dff.TrailerRowType);
Assert.IsNull(dff.TrailerRecordIdentifier);
Assert.IsNull(dff.TrailerValidator);
Assert.AreEqual(StringTransform.EmptyToNull, dff.StringTransform);
Assert.AreEqual(StringTrim.End, dff.StringTrim);
}
public void Prop_TextQualifierHandling()
{
var dff = new DelimitedFileFormat <Person>();
Assert.AreEqual(TextQualifierHandling.Strict, dff.TextQualifierHandling);
dff.TextQualifierHandling = TextQualifierHandling.LooseAllow;
Assert.AreEqual(TextQualifierHandling.LooseAllow, dff.TextQualifierHandling);
}
public void SetTrailerRowType_SameAsContentException()
{
ExpectException.Throws <InvalidOperationException>("The TrailerRowType cannot be the same as the ContentRowType.", () =>
{
var dff = new DelimitedFileFormat <Person>("X");
dff.SetTrailerRowType <Person>("T");
});
}
public void Ctor_TextWriter_ArgumentNullException()
{
Assert.Throws <ArgumentNullException>(() =>
{
var ff = new DelimitedFileFormat <Data>();
var fw = new FileWriter <Data>(null, ff);
});
}
public void Prop_ColumnCountValidation()
{
var dff = new DelimitedFileFormat <Person>();
Assert.AreEqual(ColumnCountValidation.None, dff.ColumnCountValidation);
dff.ColumnCountValidation = ColumnCountValidation.LessAndGreaterThanError;
Assert.AreEqual(ColumnCountValidation.LessAndGreaterThanError, dff.ColumnCountValidation);
}
public void Prop_StringTransform()
{
var dff = new DelimitedFileFormat <Person>();
Assert.AreEqual(StringTransform.EmptyToNull, dff.StringTransform);
dff.StringTransform = StringTransform.None;
Assert.AreEqual(StringTransform.None, dff.StringTransform);
}
public void SetTrailerRowType_SameContentRecIdException()
{
ExpectException.Throws <ArgumentException>("The TrailerRecordIdentifier cannot be the same as the ContentRecordIdentifier.", () =>
{
var dff = new DelimitedFileFormat <Person>("X");
dff.SetTrailerRowType <Trailer>("X");
});
}
public void Prop_WidthOverflow()
{
var dff = new DelimitedFileFormat <Person>();
Assert.AreEqual(ColumnWidthOverflow.Error, dff.WidthOverflow);
dff.WidthOverflow = ColumnWidthOverflow.Truncate;
Assert.AreEqual(ColumnWidthOverflow.Truncate, dff.WidthOverflow);
}
public void SetHeaderRowType_SameAsContentException()
{
ExpectException.Throws <ArgumentException>("The HeaderRowType cannot be the same as the ContentRowType.", () =>
{
var dff = new DelimitedFileFormat <Person>("X");
dff.SetHeaderRowType <Person>("H");
});
}
public void SetHeaderRowType_NoRecIdException()
{
ExpectException.Throws <ArgumentNullException>("The record identifier is required where the file is considered hierarchical.", () =>
{
var dff = new DelimitedFileFormat <Person>("X");
dff.SetHeaderRowType <Header>();
});
}
public void SetHeaderRowType_NoHierarchyException()
{
ExpectException.Throws <ArgumentException>("The record identifier can not be specified where the file is not considered hierarchical.", () =>
{
var dff = new DelimitedFileFormat <Person>();
dff.SetHeaderRowType <Header>("H");
});
}
public void Ctor_TextReaderNullException()
{
Assert.Throws <ArgumentNullException>(() =>
{
var dff = new DelimitedFileFormat <Data>();
var fr = new FileReader <Data>(null, dff);
});
}
public void Prop_StringTrim()
{
var dff = new DelimitedFileFormat <Person>();
Assert.AreEqual(StringTrim.End, dff.StringTrim);
dff.StringTrim = StringTrim.Both;
Assert.AreEqual(StringTrim.Both, dff.StringTrim);
}
public void SetHeaderRowType_Default()
{
var dff = new DelimitedFileFormat <Person>();
dff.SetHeaderRowType <Header>();
Assert.AreEqual(typeof(Header), dff.HeaderRowType);
Assert.IsNull(dff.HeaderRecordIdentifier);
Assert.IsNull(dff.HeaderValidator);
}
public void Ctor_Default()
{
using (var sr = new StringReader(string.Empty))
{
var dff = new DelimitedFileFormat <Data>();
var fr = new FileReader <Data>(sr, dff);
AssertReaderReady(fr);
}
}
public void SetHeaderRowType_AlreadySetException()
{
ExpectException.Throws <InvalidOperationException>("The HeaderRowType cannot be set more than once.", () =>
{
var dff = new DelimitedFileFormat <Person>("X");
dff.SetHeaderRowType <Header>("H", HeaderValidator.Default);
dff.SetHeaderRowType <Header>("H", HeaderValidator.Default);
});
}
public void SetHeaderRowType_Override()
{
var dff = new DelimitedFileFormat <Person>("X");
dff.SetHeaderRowType <Header>("H", HeaderValidator.Default);
Assert.AreEqual(typeof(Header), dff.HeaderRowType);
Assert.AreEqual("H", dff.HeaderRecordIdentifier);
Assert.AreSame(HeaderValidator.Default, dff.HeaderValidator);
}
public void Read()
{
using (var sr = new StringReader("Col1,col2,Col3"))
{
var ff = new DelimitedFileFormat <Data>();
var fr = new FileReader <Data>(sr, ff);
ff.SetHeaderRowType <ColumnNameHeader>();
var result = fr.Read();
Assert.AreEqual(FileContentStatus.Header, result.Status);
Assert.IsFalse(result.HasErrors);
}
}
public void Read_OnlyForHeaderException()
{
ExpectException.Throws <InvalidOperationException>("The ColumnNameHeader can only be used for a Header row.", () =>
{
using (var sr = new StringReader("Col1,Col2,Col3"))
{
var ff = new DelimitedFileFormat <ColumnNameHeader>();
var fr = new FileReader <ColumnNameHeader>(sr, ff);
fr.Read();
}
});
}
public void Write_Collection_Empty()
{
var sb = new StringBuilder();
using (var sw = new StringWriter(sb))
{
var ff = new DelimitedFileFormat <Data>();
var fw = new FileWriter <Data>(sw, ff);
var result = fw.Write(new List <Data>());
Assert.AreEqual(0, result.Length);
}
}
public void Read_IsHierarchicalException()
{
ExpectException.Throws <InvalidOperationException>("The ColumnNameHeader cannot be used when the File Format is hierarchical.", () =>
{
using (var sr = new StringReader("Z"))
{
var ff = new DelimitedFileFormat <HierarchyDataA>("A");
ff.SetHeaderRowType <ColumnNameHeader>("Z");
var fr = new FileReader <HierarchyDataA>(sr, ff);
fr.Read();
}
});
}
public void Execute_BothColumnAndHierarchyAttributesException()
{
ExpectException.Throws <InvalidOperationException>("Type 'BothColumnAndHierarchyAttributes' property 'Data' cannot specify both a FileColumnAttribute and FileHierarchyAttribute.", () =>
{
using (var sr = new StringReader("X"))
{
var ff = new DelimitedFileFormat <BothColumnAndHierarchyAttributes>(FileFormatBase.TabCharacter);
var fr = new FileReader <BothColumnAndHierarchyAttributes>(sr, ff);
var result = fr.Read();
}
});
}
public void Execute_DuplicateRecordIdentifierException()
{
ExpectException.Throws <InvalidOperationException>("Type 'DuplicateRecordIdentifier' property 'C' FileHierarchyAttribute has a duplicate Record Identifier 'A' (must be unique within Type).", () =>
{
using (var sr = new StringReader("X"))
{
var ff = new DelimitedFileFormat <DuplicateRecordIdentifier>(FileFormatBase.TabCharacter);
var fr = new FileReader <DuplicateRecordIdentifier>(sr, ff);
var result = fr.Read();
}
});
}
public void Prop_FileValidation()
{
var dff = new DelimitedFileFormat <Person>();
Assert.AreEqual(FileValidation.Unspecified, dff.FileValidation);
dff.FileValidation = FileValidation.MustHaveHeaderRow | FileValidation.MustHaveTrailerRow;
Assert.IsTrue(dff.FileValidation.HasFlag(FileValidation.MustHaveHeaderRow));
Assert.IsTrue(dff.FileValidation.HasFlag(FileValidation.MustHaveTrailerRow));
Assert.IsFalse(dff.FileValidation.HasFlag(FileValidation.MustHaveAtLeastOneContentRow));
Assert.IsFalse(dff.FileValidation.HasFlag(FileValidation.MustHaveRows));
Assert.AreEqual(TextQualifierHandling.Strict, dff.TextQualifierHandling);
}
public void WriteHeader_NoHeaderRowTypeException()
{
ExpectException.Throws <InvalidOperationException>("FileFormat has no corresponding HeaderRowType specified.", () =>
{
var sb = new StringBuilder();
using (var sw = new StringWriter(sb))
{
var ff = new DelimitedFileFormat <Data>();
var fw = new FileWriter <Data>(sw, ff);
fw.WriteHeader(new Header());
}
});
}
