public void OnlyParameters()
{
ParameterizedString ps = new ParameterizedString("$p1$$p2$$p3$", "$");
Assert.AreEqual(3, ps.Parameters.Count);
Assert.AreEqual(string.Empty, ps.ToString());
}
public void OnlyDelimiters()
{
ParameterizedString ps = new ParameterizedString("$$$$$$$$$$$$$$$$$", "$");
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("$$$$$$$$$$$$$$$$$", ps.ToString());
}
public void LeadingDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: $paramter1$ and parameter:$paramter2$$$", "$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter:$$", ps.ToString());
}
public void StartsWithDelimiter()
{
ParameterizedString ps = new ParameterizedString("$P1 parameter is at the begging of string", "$");
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("$P1 parameter is at the begging of string", ps.ToString());
}
public void MultiCharDelimiterOnlyDelimiters()
{
ParameterizedString ps = new ParameterizedString("D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$", "D$");
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$", ps.ToString());
}
public void MultiCharDelimiterOnlyParameters()
{
ParameterizedString ps = new ParameterizedString("D$p1D$D$p2D$D$p3D$", "D$");
Assert.AreEqual(3, ps.Parameters.Count);
Assert.AreEqual(string.Empty, ps.ToString());
}
public void MultiCharDelimiterLeadingDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: D$paramter1D$ and parameter:D$paramter2D$D$D$", "D$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter:D$D$", ps.ToString());
}
public void NoParameter()
{
ParameterizedString ps = new ParameterizedString("string with no paramter", "$");
Assert.IsNotNull(ps.Parameters);
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("string with no paramter", ps.ToString());
}
public void NoParameter()
{
ParameterizedString ps = new ParameterizedString("string with no paramter", "$");
Assert.IsNotNull(ps.Parameters);
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("string with no paramter", ps.ToString());
}
public void Parameters()
{
ParameterizedString ps = new ParameterizedString("string with paramter: $paramter1$ and parameter: $paramter2$", "$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("paramter1", ps.Parameters[0].ParameterName);
Assert.AreEqual("paramter2", ps.Parameters[1].ParameterName);
ps.Parameters[0].LiteralValue = "value1";
ps.Parameters[1].LiteralValue = "value2";
Assert.AreEqual("string with paramter: value1 and parameter: value2", ps.ToString());
}
public void MultiCharDelimiterParameters()
{
ParameterizedString ps = new ParameterizedString("string with paramter: D$paramter1D$ and parameter: D$paramter2D$", "D$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("paramter1", ps.Parameters[0].ParameterName);
Assert.AreEqual("paramter2", ps.Parameters[1].ParameterName);
ps.Parameters[0].LiteralValue = "value1";
ps.Parameters[1].LiteralValue = "value2";
Assert.AreEqual("string with paramter: value1 and parameter: value2", ps.ToString());
}
public void Parameters()
{
ParameterizedString ps = new ParameterizedString("string with paramter: $paramter1$ and parameter: $paramter2$", "$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("paramter1", ps.Parameters[0].ParameterName);
Assert.AreEqual("paramter2", ps.Parameters[1].ParameterName);
ps.Parameters[0].LiteralValue = "value1";
ps.Parameters[1].LiteralValue = "value2";
Assert.AreEqual("string with paramter: value1 and parameter: value2", ps.ToString());
}
public void MultiCharDelimiterNotClosedDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: D$paramter1D$ and parameter:D$paramter2D$ and D$literal-opened-delimiter", "D$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter: and D$literal-opened-delimiter", ps.ToString());
}
public void MultiCharDelimiterOnlyParameters()
{
ParameterizedString ps = new ParameterizedString("D$p1D$D$p2D$D$p3D$", "D$");
Assert.AreEqual(3, ps.Parameters.Count);
Assert.AreEqual(string.Empty, ps.ToString());
}
public void NotClosedDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: $paramter1$ and parameter:$paramter2$ and $literal-opened-delimiter", "$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter: and $literal-opened-delimiter", ps.ToString());
}
public void OnlyParameters()
{
ParameterizedString ps = new ParameterizedString("$p1$$p2$$p3$", "$");
Assert.AreEqual(3, ps.Parameters.Count);
Assert.AreEqual(string.Empty, ps.ToString());
}
public void OnlyDelimiters()
{
ParameterizedString ps = new ParameterizedString("$$$$$$$$$$$$$$$$$", "$");
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("$$$$$$$$$$$$$$$$$", ps.ToString());
}
public void NotClosedDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: $paramter1$ and parameter:$paramter2$ and $literal-opened-delimiter", "$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter: and $literal-opened-delimiter", ps.ToString());
}
public void LeadingDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: $paramter1$ and parameter:$paramter2$$$", "$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter:$$", ps.ToString());
}
public void MultiCharDelimiterNotClosedDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: D$paramter1D$ and parameter:D$paramter2D$ and D$literal-opened-delimiter", "D$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter: and D$literal-opened-delimiter", ps.ToString());
}
public void MultiCharDelimiterParameters()
{
ParameterizedString ps = new ParameterizedString("string with paramter: D$paramter1D$ and parameter: D$paramter2D$", "D$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("paramter1", ps.Parameters[0].ParameterName);
Assert.AreEqual("paramter2", ps.Parameters[1].ParameterName);
ps.Parameters[0].LiteralValue = "value1";
ps.Parameters[1].LiteralValue = "value2";
Assert.AreEqual("string with paramter: value1 and parameter: value2", ps.ToString());
}
public void MultiCharDelimiterOnlyDelimiters()
{
ParameterizedString ps = new ParameterizedString("D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$", "D$");
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$", ps.ToString());
}
public void StartsWithDelimiter()
{
ParameterizedString ps = new ParameterizedString("$P1 parameter is at the begging of string", "$");
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("$P1 parameter is at the begging of string", ps.ToString());
}
public void MultiCharDelimiterLeadingDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: D$paramter1D$ and parameter:D$paramter2D$D$D$", "D$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter:D$D$", ps.ToString());
}
