726 lines
20 KiB
C#
Executable File
726 lines
20 KiB
C#
Executable File
//
|
|
// CommandLineBuilderTest.cs
|
|
//
|
|
// Author:
|
|
// Marek Sieradzki (marek.sieradzki@gmail.com)
|
|
//
|
|
// (C) 2006 Marek Sieradzki
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
using System;
|
|
using System.Text;
|
|
using Microsoft.Build.Framework;
|
|
using Microsoft.Build.Utilities;
|
|
using NUnit.Framework;
|
|
|
|
namespace MonoTests.Microsoft.Build.Utilities {
|
|
|
|
internal class CLBTester : CommandLineBuilder {
|
|
|
|
public new bool IsQuotingRequired (string parameter)
|
|
{
|
|
return base.IsQuotingRequired (parameter);
|
|
}
|
|
|
|
public new void VerifyThrowNoEmbeddedDoubleQuotes (string switchName,
|
|
string parameter)
|
|
{
|
|
base.VerifyThrowNoEmbeddedDoubleQuotes (switchName, parameter);
|
|
}
|
|
|
|
public new void AppendFileNameWithQuoting (string filename)
|
|
{
|
|
base.AppendFileNameWithQuoting (filename);
|
|
}
|
|
|
|
public new void AppendSpaceIfNotEmpty ()
|
|
{
|
|
base.AppendSpaceIfNotEmpty ();
|
|
}
|
|
|
|
public new void AppendTextUnquoted (string textToAppend)
|
|
{
|
|
base.AppendTextUnquoted (textToAppend);
|
|
}
|
|
|
|
public new void AppendTextWithQuoting (string textToAppend)
|
|
{
|
|
base.AppendTextWithQuoting (textToAppend);
|
|
}
|
|
|
|
public new StringBuilder CommandLine
|
|
{
|
|
get { return base.CommandLine; }
|
|
}
|
|
}
|
|
|
|
|
|
[TestFixture]
|
|
public class CommandLineBuilderTest {
|
|
|
|
CommandLineBuilder clb;
|
|
string[] array;
|
|
ITaskItem[] items;
|
|
|
|
[SetUp]
|
|
public void SetUp () {
|
|
array = new string[] { "a", "b", "c"};
|
|
items = new TaskItem [] { new TaskItem ("a"), new TaskItem ("b")};
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendFileNameIfNotNull1 ()
|
|
{
|
|
|
|
ITaskItem item;
|
|
string itemSpec = "itemSpec";
|
|
|
|
item = new TaskItem ();
|
|
item.ItemSpec = itemSpec;
|
|
item.SetMetadata ("name", "value");
|
|
clb = new CommandLineBuilder ();
|
|
clb.AppendFileNameIfNotNull (item);
|
|
|
|
Assert.AreEqual (itemSpec, clb.ToString (), "A1");
|
|
|
|
item = new TaskItem ();
|
|
item.ItemSpec = itemSpec = "a b";
|
|
clb = new CommandLineBuilder ();
|
|
clb.AppendFileNameIfNotNull (item);
|
|
|
|
Assert.AreEqual ("\"" + itemSpec + "\"", clb.ToString (), "A2");
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendFileNameIfNotNull2 ()
|
|
{
|
|
string filename = "filename.txt";
|
|
|
|
clb = new CommandLineBuilder ();
|
|
clb.AppendFileNameIfNotNull (filename);
|
|
|
|
Assert.AreEqual (filename, clb.ToString (), "A1");
|
|
|
|
filename = "a b";
|
|
clb = new CommandLineBuilder ();
|
|
clb.AppendFileNameIfNotNull (filename);
|
|
|
|
Assert.AreEqual ("\"" + filename + "\"", clb.ToString (), "A2");
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendFileNameIfNotNull3 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendFileNameIfNotNull ((string) null);
|
|
|
|
Assert.AreEqual (String.Empty, clb.ToString (), "A1");
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendFileNameIfNotNull4 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendFileNameIfNotNull ((ITaskItem) null);
|
|
|
|
Assert.AreEqual (String.Empty, clb.ToString (), "A1");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException), ExpectedMessage = "Parameter \"delimiter\" cannot be null.")]
|
|
public void TestAppendFileNamesIfNotNull1 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendFileNamesIfNotNull (array, null);
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendFileNamesIfNotNull2 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendFileNamesIfNotNull (array, String.Empty);
|
|
|
|
Assert.AreEqual ("abc", clb.ToString (), "A1");
|
|
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendFileNamesIfNotNull (array, "\t");
|
|
|
|
Assert.AreEqual ("a\tb\tc", clb.ToString (), "A2");
|
|
|
|
clb.AppendFileNamesIfNotNull ((string[]) null, "sep");
|
|
|
|
Assert.AreEqual ("a\tb\tc", clb.ToString (), "A3");
|
|
|
|
clb = new CommandLineBuilder ();
|
|
clb.AppendFileNamesIfNotNull (new string [] { "a", "b c"}, " ");
|
|
|
|
Assert.AreEqual ("a \"b c\"", clb.ToString (), "A4");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException), ExpectedMessage = "Parameter \"delimiter\" cannot be null.")]
|
|
public void TestAppendFileNamesIfNotNull3 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendFileNamesIfNotNull (items, null);
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendFileNamesIfNotNull4 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendFileNamesIfNotNull (items, String.Empty);
|
|
|
|
Assert.AreEqual ("ab", clb.ToString (), "A1");
|
|
|
|
clb.AppendFileNamesIfNotNull ((ITaskItem[]) null, "sep");
|
|
|
|
Assert.AreEqual ("ab", clb.ToString (), "A2");
|
|
|
|
clb = new CommandLineBuilder ();
|
|
clb.AppendFileNamesIfNotNull (new ITaskItem [] { new TaskItem ("a"), new TaskItem ("b c") }, " ");
|
|
|
|
Assert.AreEqual ("a \"b c\"", clb.ToString (), "A3");
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendFileNameWithQuoting1 ()
|
|
{
|
|
CLBTester clbt = new CLBTester ();
|
|
|
|
clbt.AppendFileNameWithQuoting (null);
|
|
|
|
Assert.AreEqual (String.Empty, clbt.ToString (), "A1");
|
|
|
|
clbt.AppendFileNameWithQuoting ("abc abc");
|
|
|
|
Assert.AreEqual ("\"abc abc\"", clbt.ToString (), "A2");
|
|
|
|
clbt = new CLBTester ();
|
|
|
|
clbt.AppendFileNameWithQuoting ("abc");
|
|
|
|
Assert.AreEqual ("abc", clbt.ToString (), "A3");
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendSpaceIfNotEmpty ()
|
|
{
|
|
CLBTester clbt = new CLBTester ();
|
|
|
|
clbt.AppendSpaceIfNotEmpty ();
|
|
|
|
Assert.AreEqual (String.Empty, clbt.ToString (), "A1");
|
|
|
|
clbt.AppendFileNameIfNotNull ("a");
|
|
clbt.AppendFileNameIfNotNull ("b");
|
|
|
|
Assert.AreEqual ("a b", clbt.ToString (), "A2");
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendSwitch1 ()
|
|
{
|
|
string name = "/switch";
|
|
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitch (name);
|
|
|
|
Assert.AreEqual (name, clb.ToString (), "A1");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException), ExpectedMessage = "Parameter \"switchName\" cannot be null.")]
|
|
public void TestAppendSwitch2 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitch (null);
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendSwitch3 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitch (String.Empty);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException), ExpectedMessage = "Parameter \"switchName\" cannot be null.")]
|
|
public void TestAppendSwitchIfNotNull1 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchIfNotNull (null, "parameter");
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendSwitchIfNotNull2 ()
|
|
{
|
|
string name = "/switch:";
|
|
string parameter = "parameter";
|
|
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchIfNotNull (name, (string) null);
|
|
|
|
Assert.AreEqual (String.Empty, clb.ToString (), "A1");
|
|
|
|
clb.AppendSwitchIfNotNull (name, parameter);
|
|
|
|
Assert.AreEqual (name + parameter, clb.ToString (), "A2");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException), ExpectedMessage = "Parameter \"switchName\" cannot be null.")]
|
|
public void TestAppendSwitchIfNotNull3 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchIfNotNull (null, items [0]);
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendSwitchIfNotNull4 ()
|
|
{
|
|
string name = "/switch:";
|
|
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchIfNotNull (name, (ITaskItem) null);
|
|
|
|
Assert.AreEqual (String.Empty, clb.ToString (), "A1");
|
|
|
|
clb.AppendSwitchIfNotNull (name, items [0]);
|
|
|
|
Assert.AreEqual (name + items [0].ItemSpec, clb.ToString (), "A2");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException), ExpectedMessage = "Parameter \"switchName\" cannot be null.")]
|
|
public void TestAppendSwitchIfNotNull5 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchIfNotNull (null, array, "delimiter");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException), ExpectedMessage = "Parameter \"delimiter\" cannot be null.")]
|
|
public void TestAppendSwitchIfNotNull6 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchIfNotNull ("/switch", array, null);
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendSwitchIfNotNull7 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchIfNotNull ("/switch:", (string[]) null, ";");
|
|
Assert.AreEqual (String.Empty, clb.ToString (), "A1");
|
|
|
|
clb.AppendSwitchIfNotNull ("/switch:", array, ";");
|
|
Assert.AreEqual ("/switch:a;b;c", clb.ToString (), "A2");
|
|
|
|
clb.AppendSwitchIfNotNull ("/switch:", new string[] { "a'b", "c" }, ";");
|
|
Assert.AreEqual ("/switch:a;b;c /switch:\"a'b\";c", clb.ToString(), "A3");
|
|
|
|
clb.AppendSwitchIfNotNull ("/switch:", "a;b;c");
|
|
Assert.AreEqual ("/switch:a;b;c /switch:\"a'b\";c /switch:\"a;b;c\"", clb.ToString(), "A4");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException), ExpectedMessage = "Parameter \"switchName\" cannot be null.")]
|
|
public void TestAppendSwitchIfNotNull8 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchIfNotNull (null, items, "delimiter");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException), ExpectedMessage = "Parameter \"delimiter\" cannot be null.")]
|
|
public void TestAppendSwitchIfNotNull9 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchIfNotNull ("/switch", items, null);
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendSwitchIfNotNull10 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchIfNotNull ("/switch:", (ITaskItem[]) null, ";");
|
|
Assert.AreEqual (String.Empty, clb.ToString (), "A1");
|
|
|
|
clb.AppendSwitchIfNotNull ("/switch:", items, ";");
|
|
Assert.AreEqual ("/switch:a;b", clb.ToString (), "A2");
|
|
|
|
clb.AppendSwitchIfNotNull("/switch:", new ITaskItem[] { new TaskItem("a'b"), new TaskItem("c") }, ";");
|
|
Assert.AreEqual ("/switch:a;b /switch:\"a'b\";c", clb.ToString(), "A3");
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendSwitchIfNotNul11()
|
|
{
|
|
clb = new CommandLineBuilder();
|
|
|
|
clb.AppendSwitchIfNotNull("/z:", " a b");
|
|
clb.AppendSwitchIfNotNull("/z:", "c\tb");
|
|
clb.AppendSwitchIfNotNull("/z:", "ab\n");
|
|
clb.AppendSwitchIfNotNull("/z:", "xyz\u000babc");
|
|
clb.AppendSwitchIfNotNull("/z:", "\u000cabc");
|
|
clb.AppendSwitchIfNotNull("/z:", "a 'hello' b");
|
|
clb.AppendSwitchIfNotNull("/z:", "a;b");
|
|
|
|
Assert.AreEqual("/z:\" a b\" /z:\"c\tb\" /z:\"ab\n\" " +
|
|
"/z:\"xyz\u000babc\" /z:\"\u000cabc\" /z:\"a 'hello' b\" /z:\"a;b\"",
|
|
clb.ToString(), "A1");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void TestAppendSwitchIfNotNull12()
|
|
{
|
|
clb = new CommandLineBuilder();
|
|
clb.AppendSwitchIfNotNull("/z:", "x \"hello\" y");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException), ExpectedMessage = "Parameter \"switchName\" cannot be null.")]
|
|
public void TestAppendSwitchUnquotedIfNotNull1 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchUnquotedIfNotNull (null, "parameter");
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendSwitchUnquotedIfNotNull2 ()
|
|
{
|
|
string name = "/switch:";
|
|
string parameter = "parameter";
|
|
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchUnquotedIfNotNull (name, (string) null);
|
|
|
|
Assert.AreEqual (String.Empty, clb.ToString (), "A1");
|
|
|
|
clb.AppendSwitchUnquotedIfNotNull (name, parameter);
|
|
|
|
Assert.AreEqual (name + parameter, clb.ToString (), "A2");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException), ExpectedMessage = "Parameter \"switchName\" cannot be null.")]
|
|
public void TestAppendSwitchUnquotedIfNotNull3 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchUnquotedIfNotNull (null, items [0]);
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendSwitchUnquotedIfNotNull4 ()
|
|
{
|
|
string name = "/switch:";
|
|
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchUnquotedIfNotNull (name, (ITaskItem) null);
|
|
|
|
Assert.AreEqual (String.Empty, clb.ToString (), "A1");
|
|
|
|
clb.AppendSwitchUnquotedIfNotNull (name, items [0]);
|
|
|
|
Assert.AreEqual (name + items [0].ItemSpec, clb.ToString (), "A2");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException), ExpectedMessage = "Parameter \"switchName\" cannot be null.")]
|
|
public void TestAppendSwitchUnquotedIfNotNull5 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchUnquotedIfNotNull (null, array, "delimiter");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException), ExpectedMessage = "Parameter \"delimiter\" cannot be null.")]
|
|
public void TestAppendSwitchUnquotedIfNotNull6 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchUnquotedIfNotNull ("/switch", array, null);
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendSwitchUnquotedIfNotNull7 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchUnquotedIfNotNull ("/switch:", (string[]) null, ";");
|
|
|
|
Assert.AreEqual (String.Empty, clb.ToString (), "A1");
|
|
|
|
clb.AppendSwitchUnquotedIfNotNull ("/switch:", array, ";");
|
|
|
|
Assert.AreEqual ("/switch:a;b;c", clb.ToString (), "A2");
|
|
|
|
clb.AppendSwitchUnquotedIfNotNull ("/switch:", new string[] { "a'b", "c", "d" }, ";");
|
|
Assert.AreEqual ("/switch:a;b;c /switch:a'b;c;d", clb.ToString(), "A3");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException), ExpectedMessage = "Parameter \"switchName\" cannot be null.")]
|
|
public void TestAppendSwitchUnquotedIfNotNull8 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchUnquotedIfNotNull (null, items, "delimiter");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException), ExpectedMessage = "Parameter \"delimiter\" cannot be null.")]
|
|
public void TestAppendSwitchUnquotedIfNotNull9 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchUnquotedIfNotNull ("/switch", items, null);
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendTextUnquoted ()
|
|
{
|
|
CLBTester clbt = new CLBTester ();
|
|
|
|
clbt.AppendTextUnquoted (null);
|
|
|
|
clbt.AppendTextUnquoted ("a b");
|
|
|
|
Assert.AreEqual ("a b", clbt.ToString (), "A1");
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendTextWithQuoting ()
|
|
{
|
|
CLBTester clbt = new CLBTester ();
|
|
|
|
clbt.AppendTextWithQuoting (null);
|
|
|
|
clbt.AppendTextUnquoted ("a b");
|
|
|
|
Assert.AreEqual ("a b", clbt.ToString (), "A1");
|
|
|
|
clbt = new CLBTester ();
|
|
clbt.AppendTextWithQuoting ("a");
|
|
|
|
Assert.AreEqual ("a", clbt.ToString (), "A2");
|
|
}
|
|
|
|
[Test]
|
|
public void TestAppendUnquotedSwitchIfNotNull10 ()
|
|
{
|
|
clb = new CommandLineBuilder ();
|
|
|
|
clb.AppendSwitchUnquotedIfNotNull ("/switch:", (ITaskItem[]) null, ";");
|
|
|
|
Assert.AreEqual (String.Empty, clb.ToString (), "A1");
|
|
|
|
clb.AppendSwitchUnquotedIfNotNull ("/switch:", items, ";");
|
|
|
|
Assert.AreEqual ("/switch:a;b", clb.ToString (), "A2");
|
|
}
|
|
|
|
[Test]
|
|
public void TestCommandLine ()
|
|
{
|
|
CLBTester clbt = new CLBTester ();
|
|
clbt.AppendFileNameIfNotNull ("a");
|
|
Assert.AreEqual (clbt.ToString (), clbt.CommandLine.ToString (), "A1");
|
|
}
|
|
|
|
[Test]
|
|
public void TestIsQuotingRequired ()
|
|
{
|
|
CLBTester clbt = new CLBTester ();
|
|
|
|
Assert.AreEqual (false, clbt.IsQuotingRequired (null), "A0");
|
|
Assert.AreEqual (false, clbt.IsQuotingRequired (""), "A1");
|
|
Assert.AreEqual (true, clbt.IsQuotingRequired (" "), "A2");
|
|
Assert.AreEqual (false, clbt.IsQuotingRequired ("a"), "A3");
|
|
Assert.AreEqual (true, clbt.IsQuotingRequired ("a a"), "A4");
|
|
Assert.AreEqual (true, clbt.IsQuotingRequired ("\'\'"), "A5");
|
|
Assert.AreEqual (true, clbt.IsQuotingRequired ("\' \'"), "A6");
|
|
Assert.AreEqual (true, clbt.IsQuotingRequired ("\"\""), "A7");
|
|
Assert.AreEqual (true, clbt.IsQuotingRequired ("\" \""), "A8");
|
|
Assert.AreEqual (true, clbt.IsQuotingRequired ("\n\n"), "A9");
|
|
Assert.AreEqual (true, clbt.IsQuotingRequired ("\n \n"), "A10");
|
|
Assert.AreEqual (true, clbt.IsQuotingRequired ("\t\t"), "A11");
|
|
Assert.AreEqual (true, clbt.IsQuotingRequired ("\t \t"), "A12");
|
|
Assert.AreEqual (true, clbt.IsQuotingRequired("a;b"), "A13");
|
|
Assert.AreEqual (true, clbt.IsQuotingRequired("a\u000bc"), "A14");
|
|
Assert.AreEqual (true, clbt.IsQuotingRequired("a\u000cx"), "A15");
|
|
Assert.AreEqual (true, clbt.IsQuotingRequired("\""), "A16");
|
|
Assert.AreEqual (true, clbt.IsQuotingRequired(" abc"), "A17");
|
|
}
|
|
|
|
[Test]
|
|
public void TestVerifyThrowNoEmbeddedDoubleQuotes1 ()
|
|
{
|
|
CLBTester clbt = new CLBTester ();
|
|
|
|
clbt.VerifyThrowNoEmbeddedDoubleQuotes (null, null);
|
|
clbt.VerifyThrowNoEmbeddedDoubleQuotes ("", null);
|
|
clbt.VerifyThrowNoEmbeddedDoubleQuotes (null, "");
|
|
clbt.VerifyThrowNoEmbeddedDoubleQuotes (" ", "");
|
|
clbt.VerifyThrowNoEmbeddedDoubleQuotes ("", " ");
|
|
clbt.VerifyThrowNoEmbeddedDoubleQuotes ("\"abc\"", "");
|
|
clbt.VerifyThrowNoEmbeddedDoubleQuotes ("x\"y", "");
|
|
clbt.VerifyThrowNoEmbeddedDoubleQuotes ("\'\'", "\'\'");
|
|
}
|
|
|
|
[Test]
|
|
public void TestVerifyThrowNoEmbeddedDoubleQuotes2 ()
|
|
{
|
|
CheckVerifyThrowNoEmbeddedDoubleQuotes (new CLBTester (), "a",
|
|
"\"a\"", true, typeof (ArgumentException), "A1");
|
|
}
|
|
|
|
[Test]
|
|
public void TestVerifyThrowNoEmbeddedDoubleQuotes3 ()
|
|
{
|
|
CheckVerifyThrowNoEmbeddedDoubleQuotes (new CLBTester (), "a", "\"\"", true, typeof(ArgumentException), "A1");
|
|
}
|
|
|
|
[Test]
|
|
public void TestVerifyThrowNoEmbeddedDoubleQuotes4 ()
|
|
{
|
|
CheckVerifyThrowNoEmbeddedDoubleQuotes (new CLBTester (), "a", "\"foo", true, typeof(ArgumentException), "A1");
|
|
}
|
|
|
|
[Test]
|
|
public void TestVerifyThrowNoEmbeddedDoubleQuotes5 ()
|
|
{
|
|
CheckVerifyThrowNoEmbeddedDoubleQuotes (new CLBTester (), null, "a\"b", true, typeof(ArgumentException), "A1");
|
|
}
|
|
|
|
private void CheckVerifyThrowNoEmbeddedDoubleQuotes(CLBTester clbt, string switchName, string parameter,
|
|
bool expectException, Type exceptionType, string id)
|
|
{
|
|
try
|
|
{
|
|
clbt.VerifyThrowNoEmbeddedDoubleQuotes(switchName, parameter);
|
|
} catch (Exception e) {
|
|
if (!expectException)
|
|
Assert.Fail("({0}) Unexpected exception : {1}", id, exceptionType.ToString());
|
|
if (e.GetType () != exceptionType)
|
|
Assert.Fail("({0}) Expected exception of {1} type but got {2}", id, exceptionType.ToString(), e.ToString());
|
|
return;
|
|
}
|
|
|
|
if (expectException)
|
|
Assert.Fail("({0}) Didn't get expected exception {1}", id, exceptionType.ToString());
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void TestEmbeddedQuotes1()
|
|
{
|
|
new CommandLineBuilder().AppendFileNameIfNotNull("a\"b");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void TestEmbeddedQuotes2()
|
|
{
|
|
new CommandLineBuilder().AppendFileNameIfNotNull(new TaskItem ("a\"b"));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void TestEmbeddedQuotes3()
|
|
{
|
|
new CommandLineBuilder().AppendFileNamesIfNotNull(new ITaskItem[] { new TaskItem ("xyz"), new TaskItem("a\"b") }, ":");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void TestEmbeddedQuotes4()
|
|
{
|
|
new CommandLineBuilder().AppendFileNamesIfNotNull(new string[] { "xyz", "a\"b" }, ":");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void TestEmbeddedQuotes5()
|
|
{
|
|
new CommandLineBuilder().AppendSwitchIfNotNull("foo", new TaskItem("a\"b"));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void TestEmbeddedQuotes6()
|
|
{
|
|
new CommandLineBuilder().AppendSwitchIfNotNull("foo", "a\"b");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void TestEmbeddedQuotes7()
|
|
{
|
|
new CommandLineBuilder().AppendSwitchIfNotNull("foo", new ITaskItem[] { new TaskItem ("xyz"), new TaskItem("a\"b") }, ":");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void TestEmbeddedQuotes8()
|
|
{
|
|
new CommandLineBuilder().AppendSwitchIfNotNull("foo", new string[] {"xyz", "a\"b" }, ":");
|
|
}
|
|
|
|
[Test]
|
|
public void TestEmbeddedQuotes9()
|
|
{
|
|
CommandLineBuilder clb = new CommandLineBuilder();
|
|
clb.AppendSwitchUnquotedIfNotNull("foo", new TaskItem("a\"b"));
|
|
clb.AppendSwitchUnquotedIfNotNull("foo", "a\"b");
|
|
clb.AppendSwitchUnquotedIfNotNull("foo", new ITaskItem[] { new TaskItem ("xyz"), new TaskItem("a\"b") }, ":");
|
|
clb.AppendSwitchUnquotedIfNotNull("foo", new string[] { "xyz", "a\"b" }, ":");
|
|
}
|
|
}
|
|
}
|