| // $Id$ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you 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; |
| using NUnit.Framework; |
| using org.apache.etch.tests; |
| using org.apache.etch.tests.types.Test1; |
| |
| namespace etch.tests |
| { |
| [TestFixture] |
| public class TestTest1DotCsharp |
| { |
| [TestFixtureSetUp] |
| public void First() |
| { |
| Console.WriteLine(); |
| Console.Write( "TestTest" ); |
| } |
| |
| |
| [Test] |
| public void const_booleans() |
| { |
| Assert.IsFalse( ConstsTest1.BOOL1 ); |
| Assert.IsTrue( ConstsTest1.BOOL2 ); |
| } |
| |
| [Test] |
| public void const_bytes() |
| { |
| Assert.AreEqual( sbyte.MinValue, ConstsTest1.BYTE1 ); |
| Assert.AreEqual( (sbyte) -1, ConstsTest1.BYTE2 ); |
| Assert.AreEqual( (sbyte) 0, ConstsTest1.BYTE3 ); |
| Assert.AreEqual( (sbyte) 1, ConstsTest1.BYTE4 ); |
| Assert.AreEqual( sbyte.MaxValue, ConstsTest1.BYTE5 ); |
| } |
| |
| [Test] |
| public void const_shorts() |
| { |
| |
| Assert.AreEqual( short.MinValue, ConstsTest1.SHORT1 ); |
| Assert.AreEqual( (short) -1, ConstsTest1.SHORT2 ); |
| Assert.AreEqual( (short) 0, ConstsTest1.SHORT3 ); |
| Assert.AreEqual( (short) 1, ConstsTest1.SHORT4 ); |
| Assert.AreEqual( short.MaxValue, ConstsTest1.SHORT5 ); |
| } |
| |
| [Test] |
| public void const_ints() |
| { |
| Assert.AreEqual(int.MinValue, ConstsTest1.INT1); |
| Assert.AreEqual(-1, ConstsTest1.INT2); |
| Assert.AreEqual(0, ConstsTest1.INT3); |
| Assert.AreEqual(1, ConstsTest1.INT4); |
| Assert.AreEqual(int.MaxValue, ConstsTest1.INT5); |
| } |
| |
| [Test] |
| public void const_longs() |
| { |
| Assert.AreEqual(long.MinValue, ConstsTest1.LONG1); |
| Assert.AreEqual((long)-1, ConstsTest1.LONG2); |
| Assert.AreEqual((long)0, ConstsTest1.LONG3); |
| Assert.AreEqual((long)1, ConstsTest1.LONG4); |
| Assert.AreEqual(long.MaxValue, ConstsTest1.LONG5); |
| } |
| |
| [Test] |
| public void const_floats() |
| { |
| Assert.AreEqual(1.4e-45f, ConstsTest1.FLOAT1); |
| Assert.AreEqual((float)-1, ConstsTest1.FLOAT2); |
| Assert.AreEqual((float)0, ConstsTest1.FLOAT3); |
| Assert.AreEqual((float)1, ConstsTest1.FLOAT4); |
| Assert.AreEqual(3.4028235e38f, ConstsTest1.FLOAT5); |
| } |
| |
| [Test] |
| public void const_doubles() |
| { |
| Assert.AreEqual(4.9e-324, ConstsTest1.DOUBLE1); |
| Assert.AreEqual((double)-1, ConstsTest1.DOUBLE2); |
| Assert.AreEqual((double)0, ConstsTest1.DOUBLE3); |
| Assert.AreEqual((double)1, ConstsTest1.DOUBLE4); |
| Assert.AreEqual(1.7976931348623157e308, ConstsTest1.DOUBLE5); |
| } |
| |
| [Test] |
| public void const_strings() |
| { |
| Assert.AreEqual("", ConstsTest1.STRING1); |
| Assert.AreEqual("a", ConstsTest1.STRING2); |
| Assert.AreEqual("abc", ConstsTest1.STRING3); |
| Assert.AreEqual("a\tb\tc\r\n", ConstsTest1.STRING4); |
| Assert.AreEqual("x x", ConstsTest1.STRING5); |
| Assert.AreEqual("x\u00bfx", ConstsTest1.STRING6); |
| Assert.AreEqual("x\u03a9x", ConstsTest1.STRING7); |
| Assert.AreEqual("x\\x", ConstsTest1.STRING8); |
| Assert.AreEqual("x'x", ConstsTest1.STRING9); |
| Assert.AreEqual("x\"x", ConstsTest1.STRING10); |
| } |
| |
| [Test] |
| public void enum_E1() |
| { |
| //Assert.AreEqual( 3, E1.values().Length ); |
| Assert.IsNotNull( E1.A ); |
| Assert.IsNotNull( E1.B ); |
| Assert.IsNotNull( E1.C ); |
| //Assert.AreEqual( E1.A, E1.valueOf( "A" ) ); |
| //Assert.AreEqual( E1.B, E1.valueOf( "B" ) ); |
| //Assert.AreEqual( E1.C, E1.valueOf( "C" ) ); |
| //Assert.AreEqual( 0, E1.A.ordinal() ); |
| //Assert.AreEqual( 1, E1.B.ordinal() ); |
| //Assert.AreEqual( 2, E1.C.ordinal() ); |
| } |
| |
| [Test] |
| public void struct_S1() |
| { |
| S1 s = new S1( 1, 2, 3 ); |
| Assert.AreEqual( 1, s.x ); |
| Assert.AreEqual( 2, s.y ); |
| Assert.AreEqual( 3, s.z ); |
| |
| s = new S1( null, null, null ); |
| Assert.IsNull( s.x ); |
| Assert.IsNull( s.y ); |
| Assert.IsNull( s.z ); |
| |
| s = new S1(); |
| Assert.IsNull( s.x ); |
| Assert.IsNull( s.y ); |
| Assert.IsNull( s.z ); |
| |
| s.x = 4; |
| s.y = 5; |
| s.z = 6; |
| |
| Assert.AreEqual( 4, s.x ); |
| Assert.AreEqual( 5, s.y ); |
| Assert.AreEqual( 6, s.z ); |
| |
| s.x = null; |
| Assert.IsNull( s.x ); |
| |
| s.x = 7; |
| Assert.AreEqual( 7, s.x ); |
| } |
| |
| [Test] |
| public void except_Excp1() |
| { |
| Excp1 e = new Excp1( "foo", 23 ); |
| Assert.AreEqual( "foo", e.msg ); |
| Assert.AreEqual( 23, e.code ); |
| |
| e = new Excp1( null, null ); |
| Assert.IsNull( e.msg ); |
| Assert.IsNull( e.code ); |
| |
| e = new Excp1(); |
| Assert.IsNull( e.msg ); |
| Assert.IsNull( e.code ); |
| |
| e.msg = "bar"; |
| e.code = 24; |
| |
| Assert.AreEqual( "bar", e.msg ); |
| Assert.AreEqual( 24, e.code ); |
| |
| e.msg = null; |
| e.code = null; |
| |
| Assert.IsNull( e.msg ); |
| Assert.IsNull( e.code ); |
| |
| //Throwable t = e; |
| //Assert.IsTrue( t is Exception ); |
| //Assert.IsFalse( t is RuntimeException ); |
| } |
| |
| [Test] |
| public void except_Excp2() |
| { |
| Excp2 e = new Excp2(); |
| |
| Exception t = e; |
| Assert.IsTrue( t is Exception ); |
| //Assert.IsTrue( t is RuntimeException ); |
| } |
| |
| [Test] |
| public void except_Excp3() |
| { |
| Excp3 e = new Excp3(); |
| |
| Exception t = e; |
| Assert.IsTrue( t is Exception ); |
| //Assert.IsTrue( t is RuntimeException ); |
| } |
| |
| [Test] |
| public void except_Excp4() |
| { |
| Excp4 e = new Excp4(); |
| |
| Exception t = e; |
| Assert.IsTrue( t is Exception ); |
| //Assert.IsFalse( t is Exception ); |
| } |
| |
| [Test] |
| public void method_nothing() |
| { |
| test.nothing(); |
| } |
| |
| [Test] |
| public void method_incr1() |
| { |
| Assert.AreEqual( 2, test.incr( 1 ) ); |
| } |
| |
| [Test] |
| public void method_incr2() |
| { |
| Assert.AreEqual( 3, test.incr( 2 ) ); |
| } |
| |
| [Test] |
| public void method_incr3() |
| { |
| Assert.AreEqual( -1, test.incr( -2 ) ); |
| } |
| |
| [Test] |
| public void method_sub1() |
| { |
| Assert.AreEqual( 5, test.sub( 7, 2 ) ); |
| } |
| |
| [Test] |
| public void method_sub2() |
| { |
| Assert.AreEqual( 8, test.sub( 23, 15 ) ); |
| } |
| |
| [Test] |
| public void method_sub3() |
| { |
| Assert.AreEqual( -5, test.sub( 2, 7 ) ); |
| } |
| |
| [Test] |
| public void method_sum() |
| { |
| Assert.AreEqual( 24, test.sum( new int[] { 1, 2, 3, 7, 11 } ) ); |
| } |
| |
| [Test] |
| public void method_trans1() |
| { |
| Assert.AreEqual( 2, test.trans( E1.A, 5 ) ); // divide by 2 |
| } |
| |
| [Test] |
| public void method_trans2() |
| { |
| Assert.AreEqual( 10, test.trans( E1.B, 5 ) ); // mul by 2 |
| } |
| |
| [Test] |
| public void method_trans3() |
| { |
| Assert.AreEqual( 12, test.trans( E1.C, 5 ) ); // add 7 |
| } |
| |
| [Test] |
| public void method_dist1() |
| { |
| Assert.AreEqual( Math.Sqrt( 3 ), test.dist( new S1( 1, 1, 1 ), new S1( 0, 0, 0 ) ) ); |
| } |
| |
| [Test] |
| public void method_dist2() |
| { |
| Assert.AreEqual( Math.Sqrt( 35 ), test.dist( new S1( 1, 2, 3 ), new S1( 6, 5, 4 ) ) ); |
| } |
| |
| [Test] |
| public void method_dist3() |
| { |
| Assert.AreEqual( Math.Sqrt( 56 ), test.dist( new S1( 1, 2, 3 ), new S1( -1, -2, -3 ) ) ); |
| } |
| |
| [Test] |
| public void method_fill1() |
| { |
| int[] x = test.fill( 0, 1 ); |
| Assert.AreEqual( 0, x.Length ); |
| foreach (int i in x) |
| Assert.AreEqual( 1, i ); |
| } |
| |
| [Test] |
| public void method_fill2() |
| { |
| int[] x = test.fill( 1, 2 ); |
| Assert.AreEqual( 1, x.Length ); |
| foreach (int i in x) |
| Assert.AreEqual( 2, i ); |
| } |
| |
| [Test] |
| public void method_fill3() |
| { |
| int[] x = test.fill( 2, 3 ); |
| Assert.AreEqual( 2, x.Length ); |
| foreach (int i in x) |
| Assert.AreEqual( 3, i ); |
| } |
| |
| [Test] |
| public void method_blow1() |
| { |
| try |
| { |
| test.blow( "foo", 2 ); |
| Assert.IsTrue( false, "blow did not throw" ); |
| } |
| catch( Excp1 e ) |
| { |
| Assert.AreEqual( "foo", e.msg ); |
| Assert.AreEqual( 2, e.code ); |
| } |
| } |
| |
| [Test] |
| public void method_blow2() |
| { |
| try |
| { |
| test.blow( "bar", 3 ); |
| Assert.IsTrue( false, "blow did not throw" ); |
| } |
| catch( Excp1 e ) |
| { |
| Assert.AreEqual( "bar", e.msg ); |
| Assert.AreEqual( 3, e.code ); |
| } |
| } |
| |
| [Test] |
| public void method_beets1() |
| { |
| Assert.AreEqual( 5, test.beets( E1.A ) ); |
| } |
| |
| [Test] |
| public void method_beets2() |
| { |
| try |
| { |
| test.beets( E1.B ); |
| Assert.IsTrue( false, "beets did not throw" ); |
| } |
| catch ( Excp3 ) |
| { |
| Assert.IsTrue( true ); |
| } |
| } |
| |
| [Test] |
| public void method_beets3() |
| { |
| try |
| { |
| test.beets( E1.C ); |
| Assert.IsTrue(false, "beets did not throw" ); |
| } |
| catch ( Excp4 ) |
| { |
| Assert.IsTrue( true ); |
| } |
| } |
| |
| //[Test] |
| //public void method_beets4() |
| //{ |
| // Assert.IsNull( test.beets( null ) ); |
| //} |
| |
| |
| |
| // |
| //Verify that an object can be passed as a parameter in a stuct. |
| // |
| [Test] |
| public void struct_S3() |
| { |
| testS3Helper( "bool", ConstsTest1.BOOL2 ); |
| testS3Helper( "byte", ConstsTest1.BYTE5 ); |
| testS3Helper( "short", ConstsTest1.SHORT5 ); |
| testS3Helper("int", ConstsTest1.INT5); |
| testS3Helper("long", ConstsTest1.LONG5); |
| testS3Helper("float", ConstsTest1.FLOAT5); |
| testS3Helper("double", ConstsTest1.DOUBLE5); |
| testS3Helper("string", ConstsTest1.STRING3); |
| } |
| |
| /* |
| * Verify that an array of objects can be passed as a parameter |
| * in a stuct. |
| */ |
| [Test] |
| public void struct_S4() |
| { |
| int sz = 10; |
| |
| testS4Helper(sz, "boolean", ConstsTest1.BOOL2 ); |
| testS4Helper(sz, "byte", ConstsTest1.BYTE5 ); |
| testS4Helper(sz, "short", ConstsTest1.SHORT5 ); |
| testS4Helper(sz, "int", ConstsTest1.INT5); |
| testS4Helper(sz, "long", ConstsTest1.LONG5); |
| testS4Helper(sz, "float", ConstsTest1.FLOAT5); |
| testS4Helper(sz, "double", ConstsTest1.DOUBLE5); |
| testS4Helper(sz, "string", ConstsTest1.STRING3); |
| |
| } |
| |
| // Verify that an object can be passed as a parameter in an |
| // exception |
| [Test] |
| public void except_Excp5() |
| { |
| int code = 500; |
| String msg = "Excp5"; |
| |
| testExcp5Helper(msg, code, ConstsTest1.BOOL1); |
| testExcp5Helper (msg, code, ConstsTest1.BYTE5); |
| testExcp5Helper (msg, code, ConstsTest1.SHORT5); |
| testExcp5Helper(msg, code, ConstsTest1.INT5); |
| testExcp5Helper(msg, code, ConstsTest1.LONG5); |
| testExcp5Helper(msg, code, ConstsTest1.FLOAT5); |
| testExcp5Helper(msg, code, ConstsTest1.DOUBLE5); |
| testExcp5Helper(msg, code, ConstsTest1.STRING3); |
| } |
| |
| [Test] |
| public void except_Excp6() |
| { |
| int sz = 10; |
| int code = 500; |
| String msg = "Excp6"; |
| |
| testExcp6Helper(sz, msg, code, ConstsTest1.BOOL1); |
| testExcp6Helper( sz, msg, code, ConstsTest1.BYTE5 ); |
| testExcp6Helper( sz, msg, code, ConstsTest1.SHORT5 ); |
| testExcp6Helper(sz, msg, code, ConstsTest1.INT5); |
| testExcp6Helper(sz, msg, code, ConstsTest1.LONG5); |
| testExcp6Helper(sz, msg, code, ConstsTest1.FLOAT5); |
| testExcp6Helper(sz, msg, code, ConstsTest1.DOUBLE5); |
| testExcp6Helper(sz, msg, code, ConstsTest1.STRING3); |
| } |
| |
| [Test] |
| public void method_throwExcp5() |
| { |
| String msg = "throwExcp5"; |
| int code = 500; |
| |
| method_throwExcp5Helper(msg, code, ConstsTest1.BOOL1); |
| method_throwExcp5Helper( msg, code, ConstsTest1.BYTE5 ); |
| method_throwExcp5Helper( msg, code, ConstsTest1.SHORT5 ); |
| method_throwExcp5Helper(msg, code, ConstsTest1.INT5); |
| method_throwExcp5Helper(msg, code, ConstsTest1.LONG5); |
| method_throwExcp5Helper(msg, code, ConstsTest1.FLOAT5); |
| method_throwExcp5Helper(msg, code, ConstsTest1.DOUBLE5); |
| method_throwExcp5Helper(msg, code, ConstsTest1.STRING3); |
| } |
| |
| [Test] |
| public void method_throwExcp6() |
| { |
| String msg = "throwExcp6"; |
| int code = 500; |
| int sz = 10; |
| |
| method_throwExcp6Helper(sz, msg, code, ConstsTest1.BOOL1); |
| method_throwExcp6Helper( sz, msg, code, ConstsTest1.BYTE5 ); |
| method_throwExcp6Helper( sz, msg, code, ConstsTest1.SHORT5 ); |
| method_throwExcp6Helper(sz, msg, code, ConstsTest1.INT5); |
| method_throwExcp6Helper(sz, msg, code, ConstsTest1.LONG5); |
| method_throwExcp6Helper(sz, msg, code, ConstsTest1.FLOAT5); |
| method_throwExcp6Helper(sz, msg, code, ConstsTest1.DOUBLE5); |
| method_throwExcp6Helper(sz, msg, code, ConstsTest1.STRING3); |
| |
| } |
| |
| #region Helper methods |
| |
| private void testS3Helper( string type, object value ) |
| { |
| S3 s = new S3( type, value ); |
| Assert.AreEqual( type, s.tipe ); |
| Assert.AreEqual( value, s.x ); |
| |
| s = new S3( null, null ); |
| Assert.IsNull(s.tipe); |
| Assert.IsNull( s.x ); |
| |
| s = new S3(); |
| Assert.IsNull( s.tipe ); |
| Assert.IsNull( s.x ); |
| |
| s.tipe = type; |
| s.x = value; |
| Assert.AreEqual( type, s.tipe ); |
| Assert.AreEqual( value, s.x ); |
| |
| s.x = null; |
| Assert.IsNull( s.x ); |
| |
| s.x = value; |
| Assert.AreEqual( value, s.x ); |
| } |
| |
| public void testS4Helper( int sz, string type, object value ) |
| { |
| object[] myObject = test.fillObject( sz, value ); |
| S4 s = new S4( type, myObject ); |
| Assert.AreEqual( type, s.tipe ); |
| Assert.AreEqual( sz, myObject.Length ); |
| |
| for ( int i = 0; i < myObject.Length; i++ ) |
| Assert.AreEqual( value, myObject[ i ] ); |
| } |
| |
| |
| private void testExcp5Helper( String msg, int code, Object value ) |
| { |
| Excp5 e = new Excp5( msg, code, value ); |
| Assert.AreEqual( msg, e.msg ); |
| Assert.AreEqual( code, e.code ); |
| Assert.AreEqual( value, e.x); |
| |
| e = new Excp5( null, null, null ); |
| Assert.IsNull( e.msg ); |
| Assert.IsNull( e.code ); |
| Assert.IsNull( e.x); |
| |
| e = new Excp5(); |
| Assert.IsNull( e.msg ); |
| Assert.IsNull( e.code ); |
| Assert.IsNull( e.x ); |
| |
| e.msg = msg; |
| e.code = code; |
| e.x = value; |
| |
| Assert.AreEqual( msg, e.msg ); |
| Assert.AreEqual( code, e.code ); |
| Assert.AreEqual( value, e.x ); |
| |
| e.msg = null; |
| e.code = null; |
| e.x = null; |
| |
| Assert.IsNull( e.msg ); |
| Assert.IsNull( e.code ); |
| Assert.IsNull( e.x ); |
| |
| //Throwable t = e; |
| Assert.IsTrue( e is Exception ); |
| //assertFalse( t instanceof RuntimeException ); |
| } |
| |
| private void testExcp6Helper( int sz, String msg, int code, Object value ) |
| { |
| Object[] myObject = test.fillObject( sz, value ); |
| |
| Excp6 e = new Excp6( msg, code, myObject ); |
| Assert.AreEqual( msg, e.msg ); |
| Assert.AreEqual( code, e.code ); |
| |
| for ( int i = 0; i < myObject.Length; i++ ) |
| { |
| Assert.AreEqual( value, myObject[i] ); |
| } |
| |
| e = new Excp6( null, null, null ); |
| Assert.IsNull( e.msg ); |
| Assert.IsNull( e.code ); |
| Assert.IsNull( e.x ); |
| |
| e = new Excp6(); |
| Assert.IsNull( e.msg ); |
| Assert.IsNull( e.code ); |
| Assert.IsNull( e.x ); |
| |
| e.msg = msg; |
| e.code = code; |
| e.x = myObject; |
| |
| Assert.AreEqual( msg, e.msg ); |
| Assert.AreEqual( code, e.code ); |
| |
| for ( int i = 0; i < myObject.Length ; i++ ) |
| { |
| Assert.AreEqual( value, myObject[i] ); |
| } |
| |
| e.msg = null; |
| e.code = null; |
| e.x = null; |
| |
| Assert.IsNull( e.msg ); |
| Assert.IsNull( e.code ); |
| Assert.IsNull( e.x ); |
| |
| |
| //Exception t = e; |
| Assert.IsTrue( e is Exception ); |
| // assertFalse( t is RuntimeException ); |
| } |
| |
| private void method_throwExcp5Helper( String msg, int code, Object value ) |
| { |
| try |
| { |
| test.throwExcp5( msg, code, value ); |
| Assert.Fail( "throwExcp5 did not throw" ); |
| } |
| catch ( Excp5 e ) |
| { |
| Assert.AreEqual( msg, e.msg ); |
| Assert.AreEqual( code, e.code ); |
| Assert.AreEqual( value, e.x ); |
| } |
| } |
| |
| private void method_throwExcp6Helper( int sz, String msg, int code, Object value ) |
| { |
| Object[] myObject = test.fillObject( sz, value ); |
| |
| try |
| { |
| test.throwExcp6( msg, code, myObject ); |
| Assert.Fail( "throwExcp5 did not throw" ); |
| } |
| catch ( Excp6 e ) |
| { |
| Assert.AreEqual( msg, e.msg ); |
| Assert.AreEqual( code, e.code ); |
| |
| for ( int i = 0; i < myObject.Length; i++ ) |
| { |
| Assert.AreEqual( value, e.x[ i ] ); |
| } |
| } |
| } |
| |
| private void method_fillObjectHelper( int sz, Object value ) |
| { |
| Object[] myObject = test.fillObject( sz, value ); |
| |
| for ( int i = 0; i < myObject.Length; i++ ) |
| { |
| Assert.AreEqual( value, myObject[ i ] ); |
| } |
| } |
| |
| #endregion |
| |
| private Test1 test = new FakeTest1(); |
| } |
| } |
