2006-05-20 Aaron Bockover <aaron@abock.org>

    * autogen.sh: Fixed a left over configure.in to configure.ac

    * confiugre.ac: Added check foo for NUnit

    * gstreamer-sharp.mdp:
    * gstreamer-sharp.mds: Added MonoDevelop solution

    * source/Makefile.am: Cleaned and fixed

    * tests/ConsoleUi.cs:
    * tests/ApplicationTest.cs:
    * tests/BinTest.cs:
    * tests/Makefile.am: Added NUnit test framework and a few tests for
    Gst.Application and Gst.Bin

    * gstreamer-sharp/CommonTags.cs:
    * gstreamer-sharp/*.custom:
    * gstreamer-sharp/glue/*.c: Cleaned up

    * gstreamer-sharp/Application.cs: New application bindings; fixed
    to work properly with GStreamer 0.10

    * gstreamer-sharp/Version.cs: New Gst.Version class

    * gstreamer-sharp/Makefile.am: Added Version.cs

    * gstreamer-sharp/plugins-base/PlayBin.cs: Fixed and extended PlayBin
    element binding with new (but not all) properties

    * Makefile.am: Added tests



git-svn-id: svn://anonsvn.mono-project.com/source/branches/abock/gstreamer-sharp@60902 e3ebcda4-bce8-0310-ba0a-eca2169e7518

4 files changed, 562 insertions, 0 deletions

diff --git a/tests/ApplicationTest.cs b/tests/ApplicationTest.cs
new file mode 100644
index 0000000..1babca3
--- /dev/null
+++ b/tests/ApplicationTest.cs
@@ -0,0 +1,57 @@
+//
+// ApplicationTest.cs: NUnit Test Suite for gstreamer-sharp
+//
+// Authors:
+//   Aaron Bockover (abockover@novell.com)
+//
+// (C) 2006 Novell, Inc.
+//
+
+using System;
+using NUnit.Framework;
+
+[TestFixture]
+public class ApplicationTest
+{
+    [Test]
+    public void Init()
+    {
+        Gst.Application.Init();
+        Gst.Application.Deinit();
+    }
+    
+    [Test]
+    public void InitArgs()
+    {
+        string [] args = { "arg_a", "arg_b" };
+        Gst.Application.Init("gstreamer-sharp-test", ref args);
+        Gst.Application.Deinit();
+    }
+    
+    [Test]
+    public void InitArgsCheck()
+    {
+        string [] args = { "arg_a", "arg_b" };
+        Gst.Application.InitCheck("gstreamer-sharp-test", ref args);
+        Gst.Application.Deinit();
+    }
+
+    [Test]
+    public void TestVersion()
+    {
+        Assert.AreEqual(Gst.Application.Version.Minor, 10);
+    }
+    
+    [Test]
+    public void TestVersionString()
+    {   
+        Assert.IsNotNull(Gst.Application.Version.ToString());
+    }
+    
+    [Test]
+    public void TestVersionDescription()
+    {
+        Assert.IsNotNull(Gst.Application.Version.Description);
+    }
+}
+
diff --git a/tests/BinTest.cs b/tests/BinTest.cs
new file mode 100644
index 0000000..95d839f
--- /dev/null
+++ b/tests/BinTest.cs
@@ -0,0 +1,61 @@
+//
+// BinTest.cs: NUnit Test Suite for gstreamer-sharp
+//
+// Authors:
+//   Aaron Bockover (abockover@novell.com)
+//
+// (C) 2006 Novell, Inc.
+//
+
+using System;
+using NUnit.Framework;
+
+using Gst;
+
+[TestFixture]
+public class BinTest
+{
+    [TestFixtureSetUp]
+    public void Init()
+    {
+        Application.Init();
+    }
+    
+    [TestFixtureTearDown]
+    public void Deinit()
+    {
+        Application.Deinit();
+    }
+
+    [Test]
+    public void TestAddMany()
+    {
+        Bin bin = new Bin("test-bin");
+        Element e1 = ElementFactory.Make("fakesrc", "fakesrc");
+        Element e2 = ElementFactory.Make("fakesink", "fakesink");
+        bin.AddMany(e1, e2);
+        
+        Assert.AreEqual(bin.List.Length, 2);
+        
+        e1.Dispose();
+        e2.Dispose();
+        bin.Dispose();
+    }
+    
+    [Test]
+    public void TestGetByName()
+    {
+        Bin bin = new Bin("test-bin");
+        Element e1 = ElementFactory.Make("fakesrc", "element-name");
+        bin.Add(e1);
+        
+        e1 = bin.GetByName("element-name");
+        
+        Assert.IsNotNull(e1);
+        Assert.AreEqual(e1.Name, "element-name");
+        
+        e1.Dispose();
+        bin.Dispose();
+    }
+}
+
diff --git a/tests/ConsoleUi.cs b/tests/ConsoleUi.cs
new file mode 100644
index 0000000..44edb1b
--- /dev/null
+++ b/tests/ConsoleUi.cs
@@ -0,0 +1,421 @@
+#region Copyright (c) 2002-2003, James W. Newkirk, Michael C. Two, Alexei A. Vorontsov, Charlie Poole, Philip A. Craig

+/************************************************************************************

+'

+' Copyright © 2002-2003 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov, Charlie Poole

+' Copyright © 2000-2003 Philip A. Craig

+'

+' This software is provided 'as-is', without any express or implied warranty. In no 

+' event will the authors be held liable for any damages arising from the use of this 

+' software.

+' 

+' Permission is granted to anyone to use this software for any purpose, including 

+' commercial applications, and to alter it and redistribute it freely, subject to the 

+' following restrictions:

+'

+' 1. The origin of this software must not be misrepresented; you must not claim that 

+' you wrote the original software. If you use this software in a product, an 

+' acknowledgment (see the following) in the product documentation is required.

+'

+' Portions Copyright © 2003 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov, Charlie Poole

+' or Copyright © 2000-2003 Philip A. Craig

+'

+' 2. Altered source versions must be plainly marked as such, and must not be 

+' misrepresented as being the original software.

+'

+' 3. This notice may not be removed or altered from any source distribution.

+'

+'***********************************************************************************/

+#endregion

+

+namespace NUnit.Console

+{

+	using System;

+	using System.Collections;

+	using System.Collections.Specialized;

+	using System.IO;

+	using System.Reflection;

+	using System.Xml;

+	using System.Xml.Xsl;

+	using System.Xml.XPath;

+	using System.Resources;

+	using System.Text;

+	using System.Text.RegularExpressions;

+	using System.Diagnostics;

+	using NUnit.Core;

+	using NUnit.Util;

+	

+

+	/// <summary>

+	/// Summary description for ConsoleUi.

+	/// </summary>

+	public class ConsoleUi

+	{

+		[STAThread]

+		public static int Main(string[] args)

+		{

+			ConsoleOptions options = new ConsoleOptions(args);

+			if(!options.nologo)

+				WriteCopyright();

+

+			if(options.help)

+			{

+				options.Help();

+				return 0;

+			}

+			

+			if(options.NoArgs) 

+			{

+				Console.Error.WriteLine("fatal error: no inputs specified");

+				options.Help();

+				return 0;

+			}

+			

+			if(!options.Validate())

+			{

+				Console.Error.WriteLine("fatal error: invalid arguments");

+				options.Help();

+				return 2;

+			}

+

+			try

+			{

+				ConsoleUi consoleUi = new ConsoleUi();

+				consoleUi.Execute( options );

+				return 0;

+			}

+			catch( FileNotFoundException ex )

+			{

+				Console.WriteLine( ex.Message );

+				return 2;

+			}

+			catch( BadImageFormatException ex )

+			{

+				Console.WriteLine( ex.Message );

+				return 2;

+			}

+			catch( Exception ex )

+			{

+				Console.WriteLine( "Unhandled Exception:\n{0}", ex.ToString() );

+				return 2;

+			}

+			finally

+			{

+				if(options.wait)

+				{

+					Console.Out.WriteLine("\nHit <enter> key to continue");

+					Console.ReadLine();

+				}

+			}

+		}

+

+		private static XmlTextReader GetTransformReader(ConsoleOptions parser)

+		{

+			XmlTextReader reader = null;

+			if(!parser.IsTransform)

+			{

+				Assembly assembly = Assembly.GetAssembly(typeof(XmlResultVisitor));

+				ResourceManager resourceManager = new ResourceManager("NUnit.Util.Transform",assembly);

+				string xmlData = (string)resourceManager.GetObject("Summary.xslt");

+

+				reader = new XmlTextReader(new StringReader(xmlData));

+			}

+			else

+			{

+				FileInfo xsltInfo = new FileInfo(parser.transform);

+				if(!xsltInfo.Exists)

+				{

+					Console.Error.WriteLine("Transform file: {0} does not exist", xsltInfo.FullName);

+					reader = null;

+				}

+				else

+				{

+					reader = new XmlTextReader(xsltInfo.FullName);

+				}

+			}

+

+			return reader;

+		}

+

+		private static void WriteCopyright()

+		{

+			Assembly executingAssembly = Assembly.GetExecutingAssembly();

+			System.Version version = executingAssembly.GetName().Version;

+

+			string clrPlatform = Type.GetType("Mono.Runtime", false) == null ? ".NET" : "Mono";

+			Console.WriteLine( string.Format("OS Version: {0}    {1} Version: {2}",

+				Environment.OSVersion, clrPlatform, Environment.Version ) );

+			Console.WriteLine();

+		}

+

+		private static Test MakeTestFromCommandLine(TestDomain testDomain, ConsoleOptions parser)

+		{

+			NUnitProject project;

+

+			if ( parser.IsTestProject )

+			{

+				project = NUnitProject.LoadProject( (string)parser.Parameters[0] );

+				string configName = (string) parser.config;

+				if ( configName != null )

+					project.SetActiveConfig( configName );

+			}

+			else

+				project = NUnitProject.FromAssemblies( (string[])parser.Parameters.ToArray( typeof( string ) ) );

+

+			return testDomain.Load( project, parser.fixture );

+		}

+

+		public ConsoleUi()

+		{

+		}

+

+		public int Execute( ConsoleOptions options )

+		{

+			XmlTextReader transformReader = GetTransformReader(options);

+			if(transformReader == null) return 3;

+

+			ConsoleWriter outStream = options.isOut

+				? new ConsoleWriter( new StreamWriter( options.output ) )

+				: new ConsoleWriter(Console.Out);

+

+			ConsoleWriter errorStream = options.isErr

+				? new ConsoleWriter( new StreamWriter( options.err ) )

+				: new ConsoleWriter(Console.Error);

+

+			TestDomain testDomain = new TestDomain(outStream, errorStream);

+			if ( options.noshadow  ) testDomain.ShadowCopyFiles = false;

+

+			Test test = MakeTestFromCommandLine(testDomain, options);

+

+			if(test == null)

+			{

+				Console.Error.WriteLine("Unable to locate fixture {0}", options.fixture);

+				return 2;

+			}

+

+			Directory.SetCurrentDirectory(new FileInfo((string)options.Parameters[0]).DirectoryName);

+		

+			EventListener collector = new EventCollector( options, outStream );

+

+			string savedDirectory = Environment.CurrentDirectory;

+

+			if (options.HasInclude)

+			{

+				Console.WriteLine( "Included categories: " + options.include );

+				testDomain.SetFilter( new CategoryFilter( options.IncludedCategories ) );

+			}

+			else if ( options.HasExclude )

+			{

+				Console.WriteLine( "Excluded categories: " + options.exclude );

+				testDomain.SetFilter( new CategoryFilter( options.ExcludedCategories, true ) );

+			}

+

+			TestResult result = null;

+			if ( options.thread )

+			{

+				testDomain.RunTest( collector );

+				testDomain.Wait();

+				result = testDomain.Result;

+			}

+			else

+			{

+				result = testDomain.Run( collector );

+			}

+

+			Directory.SetCurrentDirectory( savedDirectory );

+			

+			Console.WriteLine();

+

+			string xmlOutput = CreateXmlOutput( result );

+			

+			if (options.xmlConsole)

+				Console.WriteLine(xmlOutput);

+			else

+				CreateSummaryDocument(xmlOutput, transformReader);

+

+			// Write xml output here

+			string xmlResultFile = options.IsXml ? options.xml : "TestResult.xml";

+

+			using ( StreamWriter writer = new StreamWriter( xmlResultFile ) ) 

+			{

+				writer.Write(xmlOutput);

+			}

+

+			if ( testDomain != null )

+				testDomain.Unload();

+

+			return result.IsFailure ? 1 : 0;

+		}

+

+		private string CreateXmlOutput( TestResult result )

+		{

+			StringBuilder builder = new StringBuilder();

+			XmlResultVisitor resultVisitor = new XmlResultVisitor(new StringWriter( builder ), result);

+			result.Accept(resultVisitor);

+			resultVisitor.Write();

+

+			return builder.ToString();

+		}

+

+		private void CreateSummaryDocument(string xmlOutput, XmlTextReader transformReader)

+		{

+			XPathDocument originalXPathDocument = new XPathDocument(new StringReader(xmlOutput));

+			XslTransform summaryXslTransform = new XslTransform();

+			

+			// Using obsolete form for now, remove warning suppression from project after changing

+			summaryXslTransform.Load(transformReader);

+			

+			// Using obsolete form for now, remove warning suppression from project after changing

+			summaryXslTransform.Transform(originalXPathDocument,null,Console.Out);

+		}

+

+		#region Nested Class to Handle Events

+

+		private class EventCollector : LongLivingMarshalByRefObject, EventListener

+		{

+			private int testRunCount;

+			private int testIgnoreCount;

+			private int failureCount;

+			private int level;

+

+			private ConsoleOptions options;

+			private ConsoleWriter writer;

+

+			StringCollection messages;

+		

+			private bool debugger = false;

+			private string currentTestName;

+

+			public EventCollector( ConsoleOptions options, ConsoleWriter writer )

+			{

+				debugger = Debugger.IsAttached;

+				level = 0;

+				this.options = options;

+				this.writer = writer;

+				this.currentTestName = string.Empty;

+			}

+

+			public void RunStarted(Test[] tests)

+			{

+			}

+

+			public void RunFinished(TestResult[] results)

+			{

+			}

+

+			public void RunFinished(Exception exception)

+			{

+			}

+

+			public void TestFinished(TestCaseResult testResult)

+			{

+				if ( !options.xmlConsole && !options.labels )

+				{

+					if(testResult.Executed)

+					{

+						testRunCount++;

+						

+						if(testResult.IsFailure)

+						{	

+							failureCount++;

+							Console.Write("F");

+							if ( debugger )

+							{

+								messages.Add( string.Format( "{0}) {1} :", failureCount, testResult.Test.FullName ) );

+								messages.Add( testResult.Message.Trim( Environment.NewLine.ToCharArray() ) );

+

+								string stackTrace = StackTraceFilter.Filter( testResult.StackTrace );

+								string[] trace = stackTrace.Split( System.Environment.NewLine.ToCharArray() );

+								foreach( string s in trace )

+								{

+									if ( s != string.Empty )

+									{

+										string link = Regex.Replace( s.Trim(), @".* in (.*):line (.*)", "$1($2)");

+										messages.Add( string.Format( "at\n{0}", link ) );

+									}

+								}

+							}

+						}

+					}

+					else

+					{

+						testIgnoreCount++;

+						Console.Write("N");

+					}

+				}

+

+				currentTestName = string.Empty;

+			}

+

+			public void TestStarted(TestCase testCase)

+			{

+				currentTestName = testCase.FullName;

+

+				if ( options.labels )

+					writer.WriteLine("***** {0}", testCase.FullName );

+				else if ( !options.xmlConsole )

+					Console.Write(".");

+}

+

+			public void SuiteStarted(TestSuite suite) 

+			{

+				if ( debugger && level++ == 0 )

+				{

+					messages = new StringCollection();

+					testRunCount = 0;

+					testIgnoreCount = 0;

+					failureCount = 0;

+					Trace.WriteLine( "################################ UNIT TESTS ################################" );

+					Trace.WriteLine( "Running tests in '" + suite.FullName + "'..." );

+				}

+			}

+

+			public void SuiteFinished(TestSuiteResult suiteResult) 

+			{

+				if ( debugger && --level == 0) 

+				{

+					Trace.WriteLine( "############################################################################" );

+

+					if (messages.Count == 0) 

+					{

+						Trace.WriteLine( "##############                 S U C C E S S               #################" );

+					}

+					else 

+					{

+						Trace.WriteLine( "##############                F A I L U R E S              #################" );

+						

+						foreach ( string s in messages ) 

+						{

+							Trace.WriteLine(s);

+						}

+					}

+

+					Trace.WriteLine( "############################################################################" );

+					Trace.WriteLine( "Executed tests : " + testRunCount );

+					Trace.WriteLine( "Ignored tests  : " + testIgnoreCount );

+					Trace.WriteLine( "Failed tests   : " + failureCount );

+					Trace.WriteLine( "Total time     : " + suiteResult.Time + " seconds" );

+					Trace.WriteLine( "############################################################################");

+				}

+			}

+

+			public void UnhandledException( Exception exception )

+			{

+				string msg = string.Format( "##### Unhandled Exception while running {0}", currentTestName );

+

+				// If we do labels, we already have a newline

+				if ( !options.labels ) writer.WriteLine();

+				writer.WriteLine( msg );

+				writer.WriteLine( exception.ToString() );

+

+				if ( debugger )

+				{

+					Trace.WriteLine( msg );

+					Trace.WriteLine( exception.ToString() );

+				}

+			}

+		}

+

+		#endregion

+	}

+}

+

diff --git a/tests/Makefile.am b/tests/Makefile.am
new file mode 100644
index 0000000..d6909ce
--- /dev/null
+++ b/tests/Makefile.am
@@ -0,0 +1,23 @@
+MCS_FLAGS = -debug
+NUNIT_FLAGS = @MONO_NUNIT_LIBS@
+
+ASSEMBLY_NAME = gstreamer-tests
+ASSEMBLY = $(ASSEMBLY_NAME).dll
+ASSEMBLY_CSFILES = $(srcdir)/ApplicationTest.cs $(srcdir)/BinTest.cs
+
+NUNIT_TESTER_NAME = ConsoleUi
+NUNIT_TESTER = $(NUNIT_TESTER_NAME).exe
+NUNIT_TESTER_CSFILES = $(srcdir)/$(NUNIT_TESTER_NAME).cs
+
+$(ASSEMBLY): $(ASSEMBLY_CSFILES)
+	$(CSC) $(MCS_FLAGS) $(NUNIT_FLAGS) -out:$@ -target:library -r:$(top_builddir)/gstreamer-sharp/gstreamer-sharp.dll $(ASSEMBLY_CSFILES)
+
+$(NUNIT_TESTER): $(NUNIT_TESTER_CSFILES)
+	$(CSC) $(MCS_FLAGS) -out:$@ $(NUNIT_FLAGS) $(NUNIT_TESTER_CSFILES)
+
+run-test: $(NUNIT_TESTER) $(ASSEMBLY)
+	MONO_PATH="../gstreamer-sharp/" mono --debug $(NUNIT_TESTER) $(ASSEMBLY)
+
+CLEANFILES = $(ASSEMBLY) $(NUNIT_TESTER) TestResult.xml
+DISTCLEANFILES = *.mdb Makefile.in *.dll *.exe
+