public void CsvContainer_SourceListIsValidAndSettingsParameterIsValid_RelevantSettingsParameterAsExpected()
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"11", "12"
},
new List <String>()
{
"21", "22"
},
new List <String>()
{
"31", "32"
},
};
CsvSettings settings = new CsvSettings()
{
Culture = CultureInfo.InvariantCulture,
Mappings = new CsvMappings(),
Heading = true,
Exactly = true,
};
CsvContainer instance = new CsvContainer(content, settings);
Assert.That(instance.Culture, Is.SameAs(settings.Culture));
Assert.That(instance.Mappings, Is.SameAs(settings.Mappings));
Assert.That(instance.Heading, Is.True);
Assert.That(instance.Exactly, Is.True);
}
public void SetValue_HeaderAndIndexAllTypesAreInt32_ResultAsExpected(String column, Int32 index)
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
};
CsvContainer instance = new CsvContainer(content, new CsvSettings()
{
Heading = true
});
instance.SetValue <Int32>(999, column, index);
Assert.That(instance[column, index], Is.EqualTo("999"));
}
public void CsvContainer_SourceListIsValidAndSettingsParameterIsNull_RelevantSettingsParameterAsExpected()
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"11", "12"
},
new List <String>()
{
"21", "22"
},
new List <String>()
{
"31", "32"
},
};
CsvSettings settings = null;
CsvContainer instance = new CsvContainer(content, settings);
Assert.That(instance.Culture, Is.EqualTo(CultureInfo.CurrentUICulture));
Assert.That(instance.Mappings, Is.InstanceOf <CsvMappings>());
Assert.That(instance.Heading, Is.False);
Assert.That(instance.Exactly, Is.False);
}
public void SetValue_InvalidHeaderAndOrInvalidIndex_ContentIsUnchanged(String column, Int32 index)
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
};
CsvContainer instance = new CsvContainer(content, new CsvSettings()
{
Heading = true
});
String original = this.GetJoinedContent(instance.Content);
instance.SetValue <Int32>(999, column, index);
Assert.That(this.GetJoinedContent(instance.Content), Is.EqualTo(original));
}
public void GetValue_InvalidHeaderAndOrInvalidIndex_ResultIsNull(String column, Int32 index)
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
};
CsvContainer instance = new CsvContainer(content, new CsvSettings()
{
Heading = true
});
Assert.That(instance.GetValue <Int32>(column, index), Is.Null);
}
public void GetColumnIndex_ValidHeaderValue_ResultAsExpected()
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
};
CsvContainer instance = new CsvContainer(content, new CsvSettings()
{
Heading = true
})
{
Compare = StringComparison.InvariantCulture
};
Assert.That(instance.GetColumnIndex("HA"), Is.EqualTo(0));
Assert.That(instance.GetColumnIndex("HB"), Is.EqualTo(1));
Assert.That(instance.GetColumnIndex("HC"), Is.EqualTo(2));
}
public void CsvContainer_CombinationsOfWidthAndLength_ResultWidthAndLengthAsExpected(Int32 width, Int32 length, Int32 expectedWidth, Int32 expectedLength)
{
CsvContainer instance = new CsvContainer(width, length);
Assert.That(instance.Width, Is.EqualTo(expectedWidth));
Assert.That(instance.Length, Is.EqualTo(expectedLength));
}
public void ListGetter_HeaderIsInvalid_ResultIsNull(String header)
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
};
CsvContainer instance = new CsvContainer(content, new CsvSettings()
{
Heading = true
});
Assert.That(instance[header], Is.Null);
}
public void Serialize_ParametersValid_ResultAsExpected()
{
String expected = "HA,HB,HC,\r\n11,12,13,\r\n21,22,23,24\r\n31,32,,\r\n";
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
};
CsvSettings settings = new CsvSettings();
CsvContainer container = new CsvContainer(content);
String actual = container.Serialize(settings);
Assert.That(actual, Is.EqualTo(expected));
}
public void CsvContainer_SourceListInnerItemsAreNullOrEmptyOrValid_ResultContentAsExpected()
{
List <List <String> > content = new List <List <String> >()
{
new List <String>(),
new List <String>()
{
"21"
},
null,
new List <String>()
{
"41", "42"
},
};
CsvContainer instance = new CsvContainer(content);
Assert.That(instance.Width, Is.EqualTo(2));
Assert.That(instance.Length, Is.EqualTo(4));
Assert.That(instance[0, 0], Is.Null);
Assert.That(instance[1, 0], Is.Null);
Assert.That(instance[0, 1], Is.EqualTo("21"));
Assert.That(instance[1, 1], Is.Null);
Assert.That(instance[0, 2], Is.Null);
Assert.That(instance[1, 2], Is.Null);
Assert.That(instance[0, 3], Is.EqualTo("41"));
Assert.That(instance[1, 3], Is.EqualTo("42"));
}
public void Read_ColumnCountMismatch_ResultAsExpected()
{
String content =
"Label,Enabled,Number,Currency\r\n" +
"Label-1,true,42,\"1,234\"\r\n" +
"Label-2,false,23\r\n";
CsvSettings settings = new CsvSettings()
{
Heading = true
};
using (MemoryStream stream = new MemoryStream(settings.Encoding.GetBytes(content)))
{
CsvContainer actual = CsvReader.Read(stream, settings);
Assert.That(actual.GetValue <String>("label", 0), Is.EqualTo("Label-1"));
Assert.That(actual.GetValue <String>("label", 1), Is.EqualTo("Label-2"));
Assert.That(actual.GetValue <Boolean>("ENABLED", 0), Is.EqualTo(true));
Assert.That(actual.GetValue <Boolean>("ENABLED", 1), Is.EqualTo(false));
Assert.That(actual.GetValue <Int32>("NumBER", 0), Is.EqualTo(42));
Assert.That(actual.GetValue <Int32>("NumBER", 1), Is.EqualTo(23));
Assert.That(actual.GetValue <Double>("Currency", 0), Is.EqualTo(1.234));
Assert.That(actual.GetValue <Double>("Currency", 1), Is.EqualTo(null));
}
}
public void ListSetter_ColumnValueIsEmpty_ContentIsUnchanged(String header)
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC", "HD"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
};
CsvContainer instance = new CsvContainer(content, new CsvSettings()
{
Heading = true
});
String expected = this.GetJoinedContent(instance.Content);
List <String> values = new List <String>();
instance[header] = values;
Assert.That(this.GetJoinedContent(instance.Content), Is.EqualTo(expected));
}
public void Sort_HeaderOrderButHeaderIsInvalid_ThrowsNothing([Values(null, "", " ", "invalid")] String header)
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
};
CsvSettings settings = new CsvSettings()
{
Heading = true
};
CsvContainer container = new CsvContainer(content, settings);
Assert.That(() => container.Sort(header, SortOrder.Ascending), Throws.Nothing);
}
public void ListGetter_HeaderIsValid_ResultAsExpected(String header, String expected)
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
};
CsvContainer instance = new CsvContainer(content, new CsvSettings()
{
Heading = true
});
Assert.That(String.Join(",", instance[header]), Is.EqualTo(expected));
}
public void Sort_ColumnOrderButColumnIsInvalid_ThrowsNothing([Values(-1, 4)] Int32 column)
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
};
CsvContainer container = new CsvContainer(content);
Assert.That(() => container.Sort(column, SortOrder.Ascending), Throws.Nothing);
}
public void Sort_DifferentParameters_ResultAsExpected(Int32 column, Boolean heading, SortOrder order, String expected)
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
};
CsvSettings settings = new CsvSettings()
{
Heading = heading
};
CsvContainer container = new CsvContainer(content, settings);
container.Sort(column, order);
Assert.That(this.GetActualContent(container), Is.EqualTo(expected));
}
public void GetColumnIndex_InvalidHeaderValue_ResultAsExpected(Boolean heading, String header)
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
};
CsvContainer instance = new CsvContainer(content, new CsvSettings()
{
Heading = heading
});
Assert.That(instance.GetColumnIndex(header), Is.EqualTo(-1));
}
public void ListGetter_HeadingIsFalse_ResultIsNull()
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
};
CsvContainer instance = new CsvContainer(content);
Assert.That(instance["HB"], Is.Null);
}
public void Serialize_CsvSettingsIsNull_ResultIsEmpty()
{
CsvSettings settings = null;
CsvContainer container = new CsvContainer(1, 1);
Assert.That(container.Serialize(settings), Is.Empty);
}
public void ListSetter_ColumnValueIsEmpty_ContentIsUnchanged(Int32 column)
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
};
CsvContainer instance = new CsvContainer(content);
String expected = this.GetJoinedContent(instance.Content);
List <String> values = new List <String>();
instance[column] = values;
Assert.That(this.GetJoinedContent(instance.Content), Is.EqualTo(expected));
}
public void Write_CsvContainerIsValid_ResultWrittenAsexpected()
{
String expected = "HA,HB,HC\r\n11,12,13\r\n21,22,23\r\n";
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23"
},
};
CsvContainer container = new CsvContainer(content);
using (MemoryStream stream = new MemoryStream())
{
CsvWriter.Write(container, stream);
Assert.That(Encoding.UTF8.GetString(stream.ToArray()), Is.EqualTo(expected));
}
}
public void Contains_InvalidHeaderValue_ResultIsFalse(Boolean heading, String header)
{
List <List <String> > content = new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
};
CsvContainer instance = new CsvContainer(content, new CsvSettings()
{
Heading = heading
});
Assert.That(instance.Contains(header), Is.False);
}
public void ListSetter_ColumnValueListIsShorter_ContentChangedAsExpected(Int32 column, String header)
{
List <List <String> > expected = new List <List <String> >()
{
new List <String>()
{
"HA", "11", "21", "31"
},
new List <String>()
{
"HB", "12", "22", "32"
},
new List <String>()
{
"HC", "13", "23", ""
},
new List <String>()
{
"HD", "", "24", ""
},
};
expected[column] = new List <String>()
{
"??", "AA", "BB", null
};
CsvContainer instance = new CsvContainer(new List <List <String> >()
{
new List <String>()
{
"HA", "HB", "HC", "HD"
},
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
}, new CsvSettings()
{
Heading = true
});
List <String> values = new List <String>()
{
"??", "AA", "BB"
};
instance[header] = values;
Assert.That(this.GetJoinedContent(instance.Content), Is.EqualTo(this.GetJoinedContent(expected)));
}
public void CsvContainer_SourceListIsEmpty_ResultContentIsEmpty()
{
List <List <String> > content = new List <List <String> >();
CsvContainer instance = new CsvContainer(content);
Assert.That(instance.Content, Is.Empty);
}
/// <summary>
/// Gets the transformed content from given container.
/// </summary>
/// <remarks>
/// This method tries to get transformed content from source container.
/// Such a transformation is necessary because of the container uses a
/// "rotated table" for a better item access.
/// </remarks>
/// <param name="container">
/// The source container to obtain transformed content from.
/// </param>
/// <returns>
/// The transformed content, ready to write into its output.
/// </returns>
/// <exception cref="ArgumentNullException">
/// This exception is thrown if given container is <null>.
/// </exception>
private static List <List <String> > GetContentOrThrow(CsvContainer container)
{
if (container is null)
{
throw new ArgumentNullException(nameof(container), "Container to write may not be null.");
}
return(container.GetTransformedContent());
}
public void CsvContainer_WidthAndLengthValidAndSettingsParameterIsNull_RelevantSettingsParameterAsExpected()
{
CsvSettings settings = null;
CsvContainer instance = new CsvContainer(2, 3, settings);
Assert.That(instance.Culture, Is.EqualTo(CultureInfo.CurrentUICulture));
Assert.That(instance.Mappings, Is.InstanceOf <CsvMappings>());
Assert.That(instance.Heading, Is.False);
Assert.That(instance.Exactly, Is.False);
}
public void CsvContainer_SourceListInnerItemsAreNull_ResultContentIsEmpty()
{
List <List <String> > content = new List <List <String> >()
{
null, null, null
};
CsvContainer instance = new CsvContainer(content);
Assert.That(instance.Content, Is.Empty);
}
public void ListSetter_ColumnValueListIsLonger_ContentChangedAsExpected(Int32 column)
{
List <List <String> > expected = new List <List <String> >()
{
new List <String>()
{
"11", "21", "31"
},
new List <String>()
{
"12", "22", "32"
},
new List <String>()
{
"13", "23", ""
},
new List <String>()
{
"", "24", ""
},
};
expected[column] = new List <String>()
{
"AA", "BB", "CC"
};
CsvContainer instance = new CsvContainer(new List <List <String> >()
{
new List <String>()
{
"11", "12", "13"
},
new List <String>()
{
"21", "22", "23", "24"
},
new List <String>()
{
"31", "32"
},
});
List <String> values = new List <String>()
{
"AA", "BB", "CC", "DD"
};
instance[column] = values;
Assert.That(this.GetJoinedContent(instance.Content), Is.EqualTo(this.GetJoinedContent(expected)));
}
public void CsvContainer_DefaultConstructor_ResultIsDefaultSettings()
{
CsvContainer instance = new CsvContainer();
Assert.That(instance.Content.Count, Is.EqualTo(0));
Assert.That(instance.Compare, Is.EqualTo(StringComparison.OrdinalIgnoreCase));
Assert.That(instance.Culture, Is.EqualTo(CultureInfo.CurrentUICulture));
Assert.That(instance.Mappings, Is.InstanceOf <CsvMappings>());
Assert.That(instance.Heading, Is.False);
Assert.That(instance.Exactly, Is.False);
Assert.That(instance.Width, Is.Zero);
Assert.That(instance.Length, Is.Zero);
}
/// <summary>
/// This method tries to read all values from given stream using given settings.
/// </summary>
/// <remarks>
/// The settings parameter describes how the data within given file should be
/// processed. For example, users may define the expected culture, the expected
/// file encoding, which separator is used and so on.
/// </remarks>
/// <param name="stream">
/// The stream to read data from.
/// </param>
/// <param name="settings">
/// The settings to be used to process file data.
/// </param>
/// <returns>
/// An instance of class <see cref="CsvContainer"/> that contains all processed
/// CSV data items.
/// </returns>
/// <exception cref="ArgumentNullException">
/// This exception is thrown in case of given stream is invalid.
/// </exception>
/// <exception cref="ArgumentException">
/// This exception is thrown in case of given stream does not have read access.
/// </exception>
public static CsvContainer Read(Stream stream, CsvSettings settings)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream), $"The stream to read the data from is invalid.");
}
if (!stream.CanRead)
{
throw new ArgumentException("No read access to given stream.", nameof(stream));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings), "The CSV settings are invalid.");
}
CsvContainer result = new CsvContainer();
List <String> lines = new List <String>();
using (StreamReader reader = new StreamReader(stream, settings.Encoding))
{
while (!reader.EndOfStream)
{
String line = reader.ReadLine();
if (!String.IsNullOrWhiteSpace(line))
{
lines.Add(line);
}
}
}
if (lines.Count > 0)
{
Char separator = settings.Separator;
List <List <String> > content = new List <List <String> >();
for (Int32 outer = 0; outer < lines.Count; outer++)
{
content.Add(ProcessHelper.SplitIntoCells(lines[outer], separator));
}
result = new CsvContainer(content, settings);
}
return(result);
}
