How to use CtorLongArg class of Telerik.JustMock.Tests package

1/*
2 JustMock Lite
3 Copyright © 2010-2015 Progress Software Corporation
4
5   Licensed under the Apache License, Version 2.0 (the "License");
6   you may not use this file except in compliance with the License.
7   You may obtain a copy of the License at
8
9   http://www.apache.org/licenses/LICENSE-2.0
10
11   Unless required by applicable law or agreed to in writing, software
12   distributed under the License is distributed on an "AS IS" BASIS,
13   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   See the License for the specific language governing permissions and
15   limitations under the License.
16*/
17
18using System;
19
20#region JustMock Test Attributes
21#if NUNIT
22using NUnit.Framework;
23using TestCategory = NUnit.Framework.CategoryAttribute;
24using TestClass = NUnit.Framework.TestFixtureAttribute;
25using TestMethod = NUnit.Framework.TestAttribute;
26using TestInitialize = NUnit.Framework.SetUpAttribute;
27using TestCleanup = NUnit.Framework.TearDownAttribute;
28using AssertionException = NUnit.Framework.AssertionException;
29#elif XUNIT
30using Xunit;
31using Telerik.JustMock.XUnit.Test.Attributes;
32using TestCategory = Telerik.JustMock.XUnit.Test.Attributes.XUnitCategoryAttribute;
33using TestClass = Telerik.JustMock.XUnit.Test.Attributes.EmptyTestClassAttribute;
34using TestMethod = Xunit.FactAttribute;
35using TestInitialize = Telerik.JustMock.XUnit.Test.Attributes.EmptyTestInitializeAttribute;
36using TestCleanup = Telerik.JustMock.XUnit.Test.Attributes.EmptyTestCleanupAttribute;
37using AssertionException = Telerik.JustMock.XUnit.AssertFailedException;
38#elif VSTEST_PORTABLE
39using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
40using AssertionException = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.AssertFailedException;
41#else
42using Microsoft.VisualStudio.TestTools.UnitTesting;
43using AssertionException = Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException;
44#endif
45#endregion
46
47namespace Telerik.JustMock.Tests
48{
49	[TestClass]
50	public class ConstructorFixture
51	{
52		[TestMethod, TestCategory("Lite"), TestCategory("Constructor")]
53		public void ShouldCallBaseCtorWhenNotMocked()
54		{
55			Assert.Throws<ArgumentException>(() =>
56			{
57				Mock.Create<Foo>(Constructor.NotMocked);
58			});
59		}
60
61#if !(COREFX && LITE_EDITION)
62		[TestMethod, TestCategory("Lite"), TestCategory("Constructor")]
63#if SILVERLIGHT
64		[Ignore, Description("SL instance constructor mocking not implemented")]
65#endif
66		public void ShouldSkipBaseConstructorWhenMocked()
67		{
68			Assert.NotNull(Mock.Create<Foo>());
69		}
70
71		[TestMethod, TestCategory("Lite"), TestCategory("Constructor")]
72#if SILVERLIGHT
73		[Ignore, Description("SL instance constructor mocking not implemented")]
74#endif
75		public void ShouldSkipBaseConstructorOfAbstractClassWhenMocked()
76		{
77			Assert.NotNull(Mock.Create<AbstractFoo>());
78		}
79#endif
80
81#if !LITE_EDITION
82		[TestMethod, TestCategory("Elevated"), TestCategory("Constructor")]
83		public void ShouldCreateMockForFrameWorkClassWithInternalCtor()
84		{
85			var downloadDateCompleted = Mock.Create<System.IO.IsolatedStorage.IsolatedStorageFile>();
86			Assert.NotNull(downloadDateCompleted != null);
87		}
88
89		[TestMethod, TestCategory("Elevated"), TestCategory("Constructor")]
90		public void ShouldFutureMockConstructorWithArg()
91		{
92			long? arg = null;
93			Mock.Arrange(() => new CtorLongArg(Arg.AnyLong)).DoInstead<long>(x => arg = x);
94
95			new CtorLongArg(100);
96			Assert.True(arg.Value == 100);
97		}
98
99#endif
100
101		public class Foo
102		{
103			public Foo()
104			{
105				throw new ArgumentException("Failed");
106			}
107		}
108
109		public abstract class AbstractFoo
110		{
111			public AbstractFoo()
112			{
113				throw new ArgumentException("Failed");
114			}
115
116			public abstract int Id { get; set; }
117		}
118
119		[TestMethod, TestCategory("Lite"), TestCategory("Constructor")]
120		public void ShouldCallConstructorRequiringPrimitiveArgumentConversions()
121		{
122			Mock.Create<CtorLongArg>(Behavior.CallOriginal, 0);
123		}
124
125		public class CtorLongArg
126		{
127			public CtorLongArg(long l) { }
128		}
129
130		public class CallsCtor
131		{
132			public bool ok;
133
134			public CallsCtor()
135			{
136				ok = true;
137			}
138		}
139
140		[TestMethod, TestCategory("Lite"), TestCategory("Constructor")]
141		public void ShouldCallDefaultConstructorWhenExplicitlyGivenNoArguments()
142		{
143			var mock = Mock.Create<CallsCtor>(new object[0]);
144			Assert.True(mock.ok);
145		}
146	}
147}
148

Source: ConstructorFixture.cs

/*
 JustMock Lite
 Copyright © 2010-2015 Progress Software Corporation

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/

using System;

#region JustMock Test Attributes
#if NUNIT
using NUnit.Framework;
using TestCategory = NUnit.Framework.CategoryAttribute;
using TestClass = NUnit.Framework.TestFixtureAttribute;
using TestMethod = NUnit.Framework.TestAttribute;
using TestInitialize = NUnit.Framework.SetUpAttribute;
using TestCleanup = NUnit.Framework.TearDownAttribute;
using AssertionException = NUnit.Framework.AssertionException;
#elif XUNIT
using Xunit;
using Telerik.JustMock.XUnit.Test.Attributes;
using TestCategory = Telerik.JustMock.XUnit.Test.Attributes.XUnitCategoryAttribute;
using TestClass = Telerik.JustMock.XUnit.Test.Attributes.EmptyTestClassAttribute;
using TestMethod = Xunit.FactAttribute;
using TestInitialize = Telerik.JustMock.XUnit.Test.Attributes.EmptyTestInitializeAttribute;
using TestCleanup = Telerik.JustMock.XUnit.Test.Attributes.EmptyTestCleanupAttribute;
using AssertionException = Telerik.JustMock.XUnit.AssertFailedException;
#elif VSTEST_PORTABLE
using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
using AssertionException = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.AssertFailedException;
#else
using Microsoft.VisualStudio.TestTools.UnitTesting;
using AssertionException = Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException;
#endif
#endregion

namespace Telerik.JustMock.Tests
{
	[TestClass]
	public class ConstructorFixture
	{
		[TestMethod, TestCategory("Lite"), TestCategory("Constructor")]
		public void ShouldCallBaseCtorWhenNotMocked()
		{
			Assert.Throws<ArgumentException>(() =>
			{
				Mock.Create<Foo>(Constructor.NotMocked);
			});
		}

#if !(COREFX && LITE_EDITION)
		[TestMethod, TestCategory("Lite"), TestCategory("Constructor")]
#if SILVERLIGHT
		[Ignore, Description("SL instance constructor mocking not implemented")]
#endif
		public void ShouldSkipBaseConstructorWhenMocked()
		{
			Assert.NotNull(Mock.Create<Foo>());
		}

		[TestMethod, TestCategory("Lite"), TestCategory("Constructor")]
#if SILVERLIGHT
		[Ignore, Description("SL instance constructor mocking not implemented")]
#endif
		public void ShouldSkipBaseConstructorOfAbstractClassWhenMocked()
		{
			Assert.NotNull(Mock.Create<AbstractFoo>());
		}
#endif

#if !LITE_EDITION
		[TestMethod, TestCategory("Elevated"), TestCategory("Constructor")]
		public void ShouldCreateMockForFrameWorkClassWithInternalCtor()
		{
			var downloadDateCompleted = Mock.Create<System.IO.IsolatedStorage.IsolatedStorageFile>();
			Assert.NotNull(downloadDateCompleted != null);
		}

		[TestMethod, TestCategory("Elevated"), TestCategory("Constructor")]
		public void ShouldFutureMockConstructorWithArg()
		{
			long? arg = null;
			Mock.Arrange(() => new CtorLongArg(Arg.AnyLong)).DoInstead<long>(x => arg = x);

			new CtorLongArg(100);
			Assert.True(arg.Value == 100);
		}

#endif

		public class Foo
		{
			public Foo()
			{
				throw new ArgumentException("Failed");
			}
		}

		public abstract class AbstractFoo
		{
			public AbstractFoo()
			{
				throw new ArgumentException("Failed");
			}

			public abstract int Id { get; set; }
		}

		[TestMethod, TestCategory("Lite"), TestCategory("Constructor")]
		public void ShouldCallConstructorRequiringPrimitiveArgumentConversions()
		{
			Mock.Create<CtorLongArg>(Behavior.CallOriginal, 0);
		}

		public class CtorLongArg
		{
			public CtorLongArg(long l) { }
		}

		public class CallsCtor
		{
			public bool ok;

			public CallsCtor()
			{
				ok = true;
			}
		}

		[TestMethod, TestCategory("Lite"), TestCategory("Constructor")]
		public void ShouldCallDefaultConstructorWhenExplicitlyGivenNoArguments()
		{
			var mock = Mock.Create<CallsCtor>(new object[0]);
			Assert.True(mock.ok);
		}
	}
}