[hotfix][tests] Do not hide original exception in Serialization tests

Project: http://git-wip-us.apache.org/repos/asf/flink/repo
Commit: http://git-wip-us.apache.org/repos/asf/flink/commit/058c0ed1
Tree: http://git-wip-us.apache.org/repos/asf/flink/tree/058c0ed1
Diff: http://git-wip-us.apache.org/repos/asf/flink/diff/058c0ed1

Branch: refs/heads/master
Commit: 058c0ed16701ff0d88d082019cc12bd5a923958f
Parents: c520f6b
Author: Piotr Nowojski <piotr.nowoj...@gmail.com>
Authored: Mon Jan 15 12:06:31 2018 +0100
Committer: Piotr Nowojski <piotr.nowoj...@gmail.com>
Committed: Mon Feb 19 12:21:09 2018 +0100

----------------------------------------------------------------------
 .../SpanningRecordSerializationTest.java        |  48 ++-----
 .../SpanningRecordSerializerTest.java           | 138 +++++++------------
 .../chaining/ChainedAllReduceDriverTest.java    |  93 ++++++-------
 3 files changed, 104 insertions(+), 175 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/flink/blob/058c0ed1/flink-runtime/src/test/java/org/apache/flink/runtime/io/network/api/serialization/SpanningRecordSerializationTest.java
----------------------------------------------------------------------
diff --git 
a/flink-runtime/src/test/java/org/apache/flink/runtime/io/network/api/serialization/SpanningRecordSerializationTest.java
 
b/flink-runtime/src/test/java/org/apache/flink/runtime/io/network/api/serialization/SpanningRecordSerializationTest.java
index ebe588c..7f3c3e5 100644
--- 
a/flink-runtime/src/test/java/org/apache/flink/runtime/io/network/api/serialization/SpanningRecordSerializationTest.java
+++ 
b/flink-runtime/src/test/java/org/apache/flink/runtime/io/network/api/serialization/SpanningRecordSerializationTest.java
@@ -36,63 +36,39 @@ import static 
org.apache.flink.runtime.io.network.buffer.BufferBuilderTestUtils.
 public class SpanningRecordSerializationTest {
 
        @Test
-       public void testIntRecordsSpanningMultipleSegments() {
+       public void testIntRecordsSpanningMultipleSegments() throws Exception {
                final int segmentSize = 1;
                final int numValues = 10;
 
-               try {
-                       
testNonSpillingDeserializer(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
-                       testSpillingDeserializer(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
-               }
-               catch (Exception e) {
-                       e.printStackTrace();
-                       Assert.fail("Test encountered an unexpected 
exception.");
-               }
+               testNonSpillingDeserializer(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
+               testSpillingDeserializer(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
        }
 
        @Test
-       public void testIntRecordsWithAlignedBuffers () {
+       public void testIntRecordsWithAlignedBuffers () throws Exception {
                final int segmentSize = 64;
                final int numValues = 64;
 
-               try {
-                       
testNonSpillingDeserializer(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
-                       testSpillingDeserializer(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
-               }
-               catch (Exception e) {
-                       e.printStackTrace();
-                       Assert.fail("Test encountered an unexpected 
exception.");
-               }
+               testNonSpillingDeserializer(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
+               testSpillingDeserializer(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
        }
 
        @Test
-       public void testIntRecordsWithUnalignedBuffers () {
+       public void testIntRecordsWithUnalignedBuffers () throws Exception {
                final int segmentSize = 31;
                final int numValues = 248;
 
-               try {
-                       
testNonSpillingDeserializer(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
-                       testSpillingDeserializer(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
-               }
-               catch (Exception e) {
-                       e.printStackTrace();
-                       Assert.fail("Test encountered an unexpected 
exception.");
-               }
+               testNonSpillingDeserializer(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
+               testSpillingDeserializer(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
        }
 
        @Test
-       public void testRandomRecords () {
+       public void testRandomRecords () throws Exception {
                final int segmentSize = 127;
                final int numValues = 10000;
 
-               try {
-                       
testNonSpillingDeserializer(Util.randomRecords(numValues), segmentSize);
-                       testSpillingDeserializer(Util.randomRecords(numValues), 
segmentSize);
-               }
-               catch (Exception e) {
-                       e.printStackTrace();
-                       Assert.fail("Test encountered an unexpected 
exception.");
-               }
+               testNonSpillingDeserializer(Util.randomRecords(numValues), 
segmentSize);
+               testSpillingDeserializer(Util.randomRecords(numValues), 
segmentSize);
        }
 
        // 
-----------------------------------------------------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/flink/blob/058c0ed1/flink-runtime/src/test/java/org/apache/flink/runtime/io/network/api/serialization/SpanningRecordSerializerTest.java
----------------------------------------------------------------------
diff --git 
a/flink-runtime/src/test/java/org/apache/flink/runtime/io/network/api/serialization/SpanningRecordSerializerTest.java
 
b/flink-runtime/src/test/java/org/apache/flink/runtime/io/network/api/serialization/SpanningRecordSerializerTest.java
index 955fc39..9f4dac6 100644
--- 
a/flink-runtime/src/test/java/org/apache/flink/runtime/io/network/api/serialization/SpanningRecordSerializerTest.java
+++ 
b/flink-runtime/src/test/java/org/apache/flink/runtime/io/network/api/serialization/SpanningRecordSerializerTest.java
@@ -39,7 +39,7 @@ import static 
org.apache.flink.runtime.io.network.buffer.BufferBuilderTestUtils.
 public class SpanningRecordSerializerTest {
 
        @Test
-       public void testHasData() {
+       public void testHasData() throws IOException {
                final int segmentSize = 16;
 
                final SpanningRecordSerializer<SerializationTestType> 
serializer = new SpanningRecordSerializer<>();
@@ -47,32 +47,26 @@ public class SpanningRecordSerializerTest {
 
                Assert.assertFalse(serializer.hasData());
 
-               try {
-                       serializer.addRecord(randomIntRecord);
-                       Assert.assertTrue(serializer.hasData());
+               serializer.addRecord(randomIntRecord);
+               Assert.assertTrue(serializer.hasData());
 
-                       
serializer.setNextBufferBuilder(createBufferBuilder(segmentSize));
-                       Assert.assertTrue(serializer.hasData());
+               
serializer.setNextBufferBuilder(createBufferBuilder(segmentSize));
+               Assert.assertTrue(serializer.hasData());
 
-                       serializer.clear();
-                       Assert.assertFalse(serializer.hasData());
+               serializer.clear();
+               Assert.assertFalse(serializer.hasData());
 
-                       
serializer.setNextBufferBuilder(createBufferBuilder(segmentSize));
+               
serializer.setNextBufferBuilder(createBufferBuilder(segmentSize));
 
-                       serializer.addRecord(randomIntRecord);
-                       Assert.assertTrue(serializer.hasData());
+               serializer.addRecord(randomIntRecord);
+               Assert.assertTrue(serializer.hasData());
 
-                       serializer.addRecord(randomIntRecord);
-                       Assert.assertTrue(serializer.hasData());
-               }
-               catch (Exception e) {
-                       e.printStackTrace();
-                       Assert.fail(e.getMessage());
-               }
+               serializer.addRecord(randomIntRecord);
+               Assert.assertTrue(serializer.hasData());
        }
 
        @Test
-       public void testEmptyRecords() {
+       public void testEmptyRecords() throws IOException {
                final int segmentSize = 11;
 
                final SpanningRecordSerializer<SerializationTestType> 
serializer = new SpanningRecordSerializer<>();
@@ -86,107 +80,77 @@ public class SpanningRecordSerializerTest {
                        Assert.fail(e.getMessage());
                }
 
-               try {
-                       SerializationTestType emptyRecord = new 
SerializationTestType() {
-                               @Override
-                               public SerializationTestType getRandom(Random 
rnd) {
-                                       throw new 
UnsupportedOperationException();
-                               }
+               SerializationTestType emptyRecord = new SerializationTestType() 
{
+                       @Override
+                       public SerializationTestType getRandom(Random rnd) {
+                               throw new UnsupportedOperationException();
+                       }
 
-                               @Override
-                               public int length() {
-                                       throw new 
UnsupportedOperationException();
-                               }
+                       @Override
+                       public int length() {
+                               throw new UnsupportedOperationException();
+                       }
 
-                               @Override
-                               public void write(DataOutputView out) {}
+                       @Override
+                       public void write(DataOutputView out) {}
 
-                               @Override
-                               public void read(DataInputView in) {}
+                       @Override
+                       public void read(DataInputView in) {}
 
-                               @Override
-                               public int hashCode() {
-                                       throw new 
UnsupportedOperationException();
-                               }
+                       @Override
+                       public int hashCode() {
+                               throw new UnsupportedOperationException();
+                       }
 
-                               @Override
-                               public boolean equals(Object obj) {
-                                       throw new 
UnsupportedOperationException();
-                               }
-                       };
+                       @Override
+                       public boolean equals(Object obj) {
+                               throw new UnsupportedOperationException();
+                       }
+               };
 
-                       RecordSerializer.SerializationResult result = 
serializer.addRecord(emptyRecord);
-                       
Assert.assertEquals(RecordSerializer.SerializationResult.FULL_RECORD, result);
+               RecordSerializer.SerializationResult result = 
serializer.addRecord(emptyRecord);
+               
Assert.assertEquals(RecordSerializer.SerializationResult.FULL_RECORD, result);
 
-                       result = serializer.addRecord(emptyRecord);
-                       
Assert.assertEquals(RecordSerializer.SerializationResult.FULL_RECORD, result);
+               result = serializer.addRecord(emptyRecord);
+               
Assert.assertEquals(RecordSerializer.SerializationResult.FULL_RECORD, result);
 
-                       result = serializer.addRecord(emptyRecord);
-                       
Assert.assertEquals(RecordSerializer.SerializationResult.PARTIAL_RECORD_MEMORY_SEGMENT_FULL,
 result);
+               result = serializer.addRecord(emptyRecord);
+               
Assert.assertEquals(RecordSerializer.SerializationResult.PARTIAL_RECORD_MEMORY_SEGMENT_FULL,
 result);
 
-                       result = 
serializer.setNextBufferBuilder(createBufferBuilder(segmentSize));
-                       
Assert.assertEquals(RecordSerializer.SerializationResult.FULL_RECORD, result);
-               }
-               catch (Exception e) {
-                       e.printStackTrace();
-                       Assert.fail(e.getMessage());
-               }
+               result = 
serializer.setNextBufferBuilder(createBufferBuilder(segmentSize));
+               
Assert.assertEquals(RecordSerializer.SerializationResult.FULL_RECORD, result);
        }
 
        @Test
-       public void testIntRecordsSpanningMultipleSegments() {
+       public void testIntRecordsSpanningMultipleSegments() throws Exception {
                final int segmentSize = 1;
                final int numValues = 10;
 
-               try {
-                       test(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
-               }
-               catch (Exception e) {
-                       e.printStackTrace();
-                       Assert.fail("Test encountered an unexpected 
exception.");
-               }
+               test(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
        }
 
        @Test
-       public void testIntRecordsWithAlignedSegments() {
+       public void testIntRecordsWithAlignedSegments() throws Exception {
                final int segmentSize = 64;
                final int numValues = 64;
 
-               try {
-                       test(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
-               }
-               catch (Exception e) {
-                       e.printStackTrace();
-                       Assert.fail("Test encountered an unexpected 
exception.");
-               }
+               test(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
        }
 
        @Test
-       public void testIntRecordsWithUnalignedSegments() {
+       public void testIntRecordsWithUnalignedSegments() throws Exception {
                final int segmentSize = 31;
                final int numValues = 248; // least common multiple => last 
record should align
 
-               try {
-                       test(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
-               }
-               catch (Exception e) {
-                       e.printStackTrace();
-                       Assert.fail("Test encountered an unexpected 
exception.");
-               }
+               test(Util.randomRecords(numValues, 
SerializationTestTypeFactory.INT), segmentSize);
        }
 
        @Test
-       public void testRandomRecords() {
+       public void testRandomRecords() throws Exception {
                final int segmentSize = 127;
                final int numValues = 100000;
 
-               try {
-                       test(Util.randomRecords(numValues), segmentSize);
-               }
-               catch (Exception e) {
-                       e.printStackTrace();
-                       Assert.fail("Test encountered an unexpected 
exception.");
-               }
+               test(Util.randomRecords(numValues), segmentSize);
        }
 
        // 
-----------------------------------------------------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/flink/blob/058c0ed1/flink-runtime/src/test/java/org/apache/flink/runtime/operators/chaining/ChainedAllReduceDriverTest.java
----------------------------------------------------------------------
diff --git 
a/flink-runtime/src/test/java/org/apache/flink/runtime/operators/chaining/ChainedAllReduceDriverTest.java
 
b/flink-runtime/src/test/java/org/apache/flink/runtime/operators/chaining/ChainedAllReduceDriverTest.java
index a81e959..0d75100 100644
--- 
a/flink-runtime/src/test/java/org/apache/flink/runtime/operators/chaining/ChainedAllReduceDriverTest.java
+++ 
b/flink-runtime/src/test/java/org/apache/flink/runtime/operators/chaining/ChainedAllReduceDriverTest.java
@@ -53,65 +53,54 @@ public class ChainedAllReduceDriverTest extends 
TaskTestBase {
        private final RecordSerializerFactory serFact = 
RecordSerializerFactory.get();
 
        @Test
-       public void testMapTask() {
+       public void testMapTask() throws Exception {
                final int keyCnt = 100;
                final int valCnt = 20;
 
                final double memoryFraction = 1.0;
 
-               try {
-                       // environment
-                       initEnvironment(MEMORY_MANAGER_SIZE, 
NETWORK_BUFFER_SIZE);
-                       mockEnv.getExecutionConfig().enableObjectReuse();
-                       addInput(new UniformRecordGenerator(keyCnt, valCnt, 
false), 0);
-                       addOutput(this.outList);
-
-                       // chained reduce config
-                       {
-                               final TaskConfig reduceConfig = new 
TaskConfig(new Configuration());
-
-                               // input
-                               reduceConfig.addInputToGroup(0);
-                               reduceConfig.setInputSerializer(serFact, 0);
-
-                               // output
-                               
reduceConfig.addOutputShipStrategy(ShipStrategyType.FORWARD);
-                               reduceConfig.setOutputSerializer(serFact);
-
-                               // driver
-                               
reduceConfig.setDriverStrategy(DriverStrategy.ALL_REDUCE);
-                               reduceConfig.setDriverComparator(compFact, 0);
-                               reduceConfig.setDriverComparator(compFact, 1);
-                               
reduceConfig.setRelativeMemoryDriver(memoryFraction);
-
-                               // udf
-                               reduceConfig.setStubWrapper(new 
UserCodeClassWrapper<>(MockReduceStub.class));
-
-                               
getTaskConfig().addChainedTask(ChainedAllReduceDriver.class, reduceConfig, 
"reduce");
-                       }
-
-                       // chained map+reduce
-                       {
-                               registerTask(FlatMapDriver.class, 
MockMapStub.class);
-                               BatchTask<FlatMapFunction<Record, Record>, 
Record> testTask = new BatchTask<>(mockEnv);
-
-                               try {
-                                       testTask.invoke();
-                               } catch (Exception e) {
-                                       e.printStackTrace();
-                                       Assert.fail("Invoke method caused 
exception.");
-                               }
-                       }
-
-                       int sumTotal = valCnt * keyCnt * (keyCnt - 1) / 2;
-
-                       Assert.assertEquals(1, this.outList.size());
-                       Assert.assertEquals(sumTotal, 
this.outList.get(0).getField(0, IntValue.class).getValue());
+               // environment
+               initEnvironment(MEMORY_MANAGER_SIZE, NETWORK_BUFFER_SIZE);
+               mockEnv.getExecutionConfig().enableObjectReuse();
+               addInput(new UniformRecordGenerator(keyCnt, valCnt, false), 0);
+               addOutput(this.outList);
+
+               // chained reduce config
+               {
+                       final TaskConfig reduceConfig = new TaskConfig(new 
Configuration());
+
+                       // input
+                       reduceConfig.addInputToGroup(0);
+                       reduceConfig.setInputSerializer(serFact, 0);
+
+                       // output
+                       
reduceConfig.addOutputShipStrategy(ShipStrategyType.FORWARD);
+                       reduceConfig.setOutputSerializer(serFact);
+
+                       // driver
+                       
reduceConfig.setDriverStrategy(DriverStrategy.ALL_REDUCE);
+                       reduceConfig.setDriverComparator(compFact, 0);
+                       reduceConfig.setDriverComparator(compFact, 1);
+                       reduceConfig.setRelativeMemoryDriver(memoryFraction);
+
+                       // udf
+                       reduceConfig.setStubWrapper(new 
UserCodeClassWrapper<>(MockReduceStub.class));
+
+                       
getTaskConfig().addChainedTask(ChainedAllReduceDriver.class, reduceConfig, 
"reduce");
                }
-               catch (Exception e) {
-                       e.printStackTrace();
-                       Assert.fail(e.getMessage());
+
+               // chained map+reduce
+               {
+                       registerTask(FlatMapDriver.class, MockMapStub.class);
+                       BatchTask<FlatMapFunction<Record, Record>, Record> 
testTask = new BatchTask<>(mockEnv);
+
+                       testTask.invoke();
                }
+
+               int sumTotal = valCnt * keyCnt * (keyCnt - 1) / 2;
+
+               Assert.assertEquals(1, this.outList.size());
+               Assert.assertEquals(sumTotal, this.outList.get(0).getField(0, 
IntValue.class).getValue());
        }
 
        public static class MockReduceStub implements ReduceFunction<Record> {

Reply via email to