SemanticPropUtilTest.java

/***********************************************************************************************************************
 * Copyright (C) 2010-2013 by the Stratosphere project (http://stratosphere.eu)
 *
 * 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.
 **********************************************************************************************************************/

package eu.stratosphere.api.java.functions;

import eu.stratosphere.api.common.InvalidProgramException;
import eu.stratosphere.api.common.operators.DualInputSemanticProperties;
import eu.stratosphere.api.common.operators.SingleInputSemanticProperties;
import eu.stratosphere.api.common.operators.util.FieldSet;
import eu.stratosphere.api.java.tuple.Tuple3;
import eu.stratosphere.api.java.tuple.Tuple4;
import eu.stratosphere.api.java.tuple.Tuple5;
import eu.stratosphere.api.java.typeutils.BasicTypeInfo;
import eu.stratosphere.api.java.typeutils.TupleTypeInfo;
import eu.stratosphere.types.TypeInformation;
import junit.framework.Assert;

import org.junit.Test;

public class SemanticPropUtilTest {
	
	// --------------------------------------------------------------------------------------------
	// Constant Fields
	// --------------------------------------------------------------------------------------------

	@Test
	public void testConstantWithArrowIndividualStrings() {
		// no spaces
		{
			String[] constantFields = { "0->0,1", "1->2" };
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
	
			FieldSet fs = sp.getForwardedField(0);
			Assert.assertTrue(fs.size() == 2);
			Assert.assertTrue(fs.contains(0));
			Assert.assertTrue(fs.contains(1));
	
			fs = sp.getForwardedField(1);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(2));
		}
		
		// with spaces
		{
			String[] constantFields = { "0 -> 0 ,   1 ", " 1     -> 2  " };
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
	
			FieldSet fs = sp.getForwardedField(0);
			Assert.assertTrue(fs.size() == 2);
			Assert.assertTrue(fs.contains(0));
			Assert.assertTrue(fs.contains(1));
	
			fs = sp.getForwardedField(1);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(2));
		}
	}
	
	@Test
	public void testConstantWithArrowIndividualStringsSpaces() {
		String[] constantFields = { "  1-> 1 , 2", "2 ->3" };

		TypeInformation<?> type = new TupleTypeInfo<Tuple4<Integer, Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
				BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
		SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);

		FieldSet fs = sp.getForwardedField(1);
		Assert.assertTrue(fs.size() == 2);
		Assert.assertTrue(fs.contains(1));
		Assert.assertTrue(fs.contains(2));

		fs = sp.getForwardedField(2);
		Assert.assertTrue(fs.size() == 1);
		Assert.assertTrue(fs.contains(3));
	}
	
	@Test
	public void testConstantWithArrowOneString() {
		// narrow (no spaces)
		{
			String[] constantFields = { "0->0,1;1->2" };
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
	
			FieldSet fs = sp.getForwardedField(0);
			Assert.assertTrue(fs.size() == 2);
			Assert.assertTrue(fs.contains(0));
			Assert.assertTrue(fs.contains(1));
	
			fs = sp.getForwardedField(1);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(2));
		}
		
		// wide (with spaces)
		{
			String[] constantFields = { "  0 ->  0  ,  1  ;   1  -> 2 " };
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
	
			FieldSet fs = sp.getForwardedField(0);
			Assert.assertTrue(fs.size() == 2);
			Assert.assertTrue(fs.contains(0));
			Assert.assertTrue(fs.contains(1));
	
			fs = sp.getForwardedField(1);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(2));
		}
	}
	
	@Test
	public void testConstantNoArrrowIndividualStrings() {
		// no spaces
		{
			String[] constantFields = {"2","3","0"};
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple5<Integer, Integer, Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
	
			FieldSet fs = sp.getForwardedField(0);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(0));
	
			fs = sp.getForwardedField(2);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(2));
	
			fs = sp.getForwardedField(3);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(3));
	
			Assert.assertNull(sp.getForwardedField(1));
			Assert.assertNull(sp.getForwardedField(4));
		}
		
		// with spaces
		{
			String[] constantFields = {" 2   ","3  ","  0"};
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple5<Integer, Integer, Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
	
			FieldSet fs = sp.getForwardedField(0);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(0));
	
			fs = sp.getForwardedField(2);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(2));
	
			fs = sp.getForwardedField(3);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(3));
	
			Assert.assertNull(sp.getForwardedField(1));
			Assert.assertNull(sp.getForwardedField(4));
		}
	}
	
	@Test
	public void testConstantNoArrrowOneString() {
		// no spaces
		{
			String[] constantFields = {"2;3;0"};
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple5<Integer, Integer, Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
	
			FieldSet fs = sp.getForwardedField(0);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(0));
	
			fs = sp.getForwardedField(2);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(2));
	
			fs = sp.getForwardedField(3);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(3));
	
			Assert.assertNull(sp.getForwardedField(1));
			Assert.assertNull(sp.getForwardedField(4));
		}
		
		// no spaces
		{
			String[] constantFields = {"  2  ;   3  ;  0   "};
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple5<Integer, Integer, Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
	
			FieldSet fs = sp.getForwardedField(0);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(0));
	
			fs = sp.getForwardedField(2);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(2));
	
			fs = sp.getForwardedField(3);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(3));
	
			Assert.assertNull(sp.getForwardedField(1));
			Assert.assertNull(sp.getForwardedField(4));
		}
	}
	
//	@Test
//	public void testConstantNoArrrowOneStringInvalidDelimiter() {
//		String[] constantFields = {"2,3,0"};
//
//		TypeInformation<?> type = new TupleTypeInfo<Tuple5<Integer, Integer, Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
//				BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
//		try {
//			SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
//			Assert.fail("Accepted invalid input");
//		}
//		catch (InvalidProgramException e) {
//			// bueno!
//		}
//	}
	
	@Test
	public void testConstantMixedOneString() {
		// no spaces
		{
			String[] constantFields = {"2,3;0->1,4;4->0"};
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple5<Integer, Integer, Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
	
			FieldSet fs = sp.getForwardedField(0);
			Assert.assertTrue(fs.size() == 2);
			Assert.assertTrue(fs.contains(1));
			Assert.assertTrue(fs.contains(4));
	
			fs = sp.getForwardedField(2);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(2));
	
			fs = sp.getForwardedField(3);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(3));
	
			fs = sp.getForwardedField(4);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(0));
		}
		
		// with spaces
		{
			String[] constantFields = {" 2  ,  3   ;  0 -> 1  , 4 ; 4 ->  0"};
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple5<Integer, Integer, Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
	
			FieldSet fs = sp.getForwardedField(0);
			Assert.assertTrue(fs.size() == 2);
			Assert.assertTrue(fs.contains(1));
			Assert.assertTrue(fs.contains(4));
	
			fs = sp.getForwardedField(2);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(2));
	
			fs = sp.getForwardedField(3);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(3));
	
			fs = sp.getForwardedField(4);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(0));
		}
	}

	@Test
	public void testConstantWildCard() {
		// no spaces
		{
			String[] constantFields = { "*" };
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
	
			FieldSet fs = sp.getForwardedField(1);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(1));
	
			fs = sp.getForwardedField(2);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(2));
	
			fs = sp.getForwardedField(0);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(0));
		}
		
//		// with spaces
//		{
//			String[] constantFields = { "   *   " };
//	
//			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
//					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
//			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
//	
//			FieldSet fs = sp.getForwardedField(1);
//			Assert.assertTrue(fs.size() == 1);
//			Assert.assertTrue(fs.contains(1));
//	
//			fs = sp.getForwardedField(2);
//			Assert.assertTrue(fs.size() == 1);
//			Assert.assertTrue(fs.contains(2));
//	
//			fs = sp.getForwardedField(0);
//			Assert.assertTrue(fs.size() == 1);
//			Assert.assertTrue(fs.contains(0));
//		}
	}
		

	@Test
	public void testConstantWildCard2() {
		// no spaces
		{
			String[] constantFields = { "1->*" };
			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
	
			FieldSet fs = sp.getForwardedField(1);
			Assert.assertTrue(fs.size() == 3);
			Assert.assertTrue(fs.contains(0));
			Assert.assertTrue(fs.contains(1));
			Assert.assertTrue(fs.contains(2));
			Assert.assertTrue(sp.getForwardedField(0) == null);
			Assert.assertTrue(sp.getForwardedField(2) == null);
		}
		
//		// with spaces
//		{
//			String[] constantFields = { "  1  -> * " };
//			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
//					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
//			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
//	
//			FieldSet fs = sp.getForwardedField(1);
//			Assert.assertTrue(fs.size() == 3);
//			Assert.assertTrue(fs.contains(0));
//			Assert.assertTrue(fs.contains(1));
//			Assert.assertTrue(fs.contains(2));
//			Assert.assertTrue(sp.getForwardedField(0) == null);
//			Assert.assertTrue(sp.getForwardedField(2) == null);
//		}
	}

	@Test
	public void testConstantInvalidString() {
		String[] constantFields = { "notValid" };

		TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
				BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);

		try {
			SemanticPropUtil.getSemanticPropsSingleFromString(constantFields, null, null, type, type);
			Assert.fail("accepted invalid input");
		} catch (InvalidProgramException e) {
			// good
		} catch (Exception e) {
			Assert.fail("Wrong type of exception thrown");
		}
	}
	
	// --------------------------------------------------------------------------------------------
	// Constant Fields Except
	// --------------------------------------------------------------------------------------------

	@Test
	public void testConstantExceptOneString() {
		// no spaces
		{
			String[] constantFieldsExcept = { "1" };
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(null, constantFieldsExcept, null, type, type);
	
			FieldSet fs = sp.getForwardedField(0);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(0));
	
			Assert.assertNull(sp.getForwardedField(1));
			
			fs = sp.getForwardedField(2);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(2));
		}
		
		// with spaces
		{
			String[] constantFieldsExcept = { " 1  "};
			
			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(null, constantFieldsExcept, null, type, type);
	
			FieldSet fs = sp.getForwardedField(0);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(0));
	
			Assert.assertNull(sp.getForwardedField(1));
			
			fs = sp.getForwardedField(2);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(2));
		}
	}
	
//	@Test
//	public void testConstantExceptIndividualStrings() {
//		// no spaces
//		{
//			String[] constantFieldsExcept = { "1", "2" };
//	
//			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
//					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
//			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(null, constantFieldsExcept, null, type, type);
//	
//			FieldSet fs = sp.getForwardedField(0);
//			Assert.assertTrue(fs.size() == 1);
//			Assert.assertTrue(fs.contains(0));
//	
//			Assert.assertNull(sp.getForwardedField(1));
//			Assert.assertNull(sp.getForwardedField(2));
//		}
//		
//		// with spaces
//		{
//			String[] constantFieldsExcept = { " 1  ", " 2" };
//			
//			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
//					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
//			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(null, constantFieldsExcept, null, type, type);
//	
//			FieldSet fs = sp.getForwardedField(0);
//			Assert.assertTrue(fs.size() == 1);
//			Assert.assertTrue(fs.contains(0));
//	
//			Assert.assertNull(sp.getForwardedField(1));
//			Assert.assertNull(sp.getForwardedField(2));
//		}
//	}
	
	@Test
	public void testConstantExceptSingleString() {
		// no spaces
		{
			String[] constantFieldsExcept = { "1,2" };
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(null, constantFieldsExcept, null, type, type);
	
			FieldSet fs = sp.getForwardedField(0);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(0));
	
			Assert.assertNull(sp.getForwardedField(1));
			Assert.assertNull(sp.getForwardedField(2));
		}
		
		// with spaces
		{
			String[] constantFieldsExcept = { " 1  , 2" };
			
			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(null, constantFieldsExcept, null, type, type);
	
			FieldSet fs = sp.getForwardedField(0);
			Assert.assertTrue(fs.size() == 1);
			Assert.assertTrue(fs.contains(0));
	
			Assert.assertNull(sp.getForwardedField(1));
			Assert.assertNull(sp.getForwardedField(2));
		}
	}
	
	@Test
	public void testConstantExceptString() {
		String[] constantFieldsExcept = { "notValid" };

		TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
				BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);

		try {
			SemanticPropUtil.getSemanticPropsSingleFromString(null, constantFieldsExcept, null, type, type);
			Assert.fail();
		} catch (Exception e) {
			// good
		}
	}
	
	
	// --------------------------------------------------------------------------------------------
	// Constant Fields Except
	// --------------------------------------------------------------------------------------------

	@Test
	public void testReadFieldsIndividualStrings() {
		// no spaces
		{
			String[] readFields = { "1", "2" };
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(null, null, readFields, type, type);
	
			FieldSet fs = sp.getReadFields();
			Assert.assertTrue(fs.size() == 2);
			Assert.assertTrue(fs.contains(2));
			Assert.assertTrue(fs.contains(1));
		}
		
		// with spaces
		{
			String[] readFields = { "   1    ", " 2   " };
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(null, null, readFields, type, type);
	
			FieldSet fs = sp.getReadFields();
			Assert.assertTrue(fs.size() == 2);
			Assert.assertTrue(fs.contains(2));
			Assert.assertTrue(fs.contains(1));
		}
	}
	
	@Test
	public void testReadFieldsOneString() {
		// no spaces
		{
			String[] readFields = { "1,2" };
	
			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(null, null, readFields, type, type);
	
			FieldSet fs = sp.getReadFields();
			Assert.assertTrue(fs.size() == 2);
			Assert.assertTrue(fs.contains(2));
			Assert.assertTrue(fs.contains(1));
		}
		
		// with spaces
		{
			String[] readFields = { "  1  , 2   " };
			
			TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
					BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
			SingleInputSemanticProperties sp = SemanticPropUtil.getSemanticPropsSingleFromString(null, null, readFields, type, type);
	
			FieldSet fs = sp.getReadFields();
			Assert.assertTrue(fs.size() == 2);
			Assert.assertTrue(fs.contains(2));
			Assert.assertTrue(fs.contains(1));
		}
	}

	@Test
	public void testReadFieldsInvalidString() {
		String[] readFields = { "notValid" };

		TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
				BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);

		try {
			SemanticPropUtil.getSemanticPropsSingleFromString(null, null, readFields, type, type);
			Assert.fail("accepted invalid input");
		} catch (InvalidProgramException e) {
			// good
		} catch (Exception e) {
			Assert.fail("Wrong type of exception thrown");
		}
	}
	
	// --------------------------------------------------------------------------------------------
	// Two Inputs
	// --------------------------------------------------------------------------------------------
	
	@Test
	public void testSimpleCaseDual() {
		String[] constantFieldsFirst = { "1->1,2", "2->3" };
		String[] constantFieldsSecond = { "1->1,2", "2->3" };

		TypeInformation<?> type = new TupleTypeInfo<Tuple4<Integer, Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
				BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
		
		
		DualInputSemanticProperties dsp = new DualInputSemanticProperties();
		
		SemanticPropUtil.getSemanticPropsDualFromString(dsp, constantFieldsFirst, constantFieldsSecond, null,
				null, null, null, type, type, type);

		FieldSet fs = dsp.getForwardedField1(1);
		Assert.assertTrue(fs.size() == 2);
		Assert.assertTrue(fs.contains(1));
		Assert.assertTrue(fs.contains(2));

		fs = dsp.getForwardedField1(2);
		Assert.assertTrue(fs.size() == 1);
		Assert.assertTrue(fs.contains(3));
	}

	@Test
	public void testFieldsExceptDual() {
		String[] constantFieldsFirstExcept = { "1,2" };
		String[] constantFieldsSecond = { "0->1" };

		DualInputSemanticProperties dsp = new DualInputSemanticProperties();
		
		TypeInformation<?> type = new TupleTypeInfo<Tuple3<Integer, Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO,
				BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
		SemanticPropUtil.getSemanticPropsDualFromString(dsp, null, constantFieldsSecond,
				constantFieldsFirstExcept, null, null, null, type, type, type);

		FieldSet fs = dsp.getForwardedField1(0);
		Assert.assertTrue(fs.size() == 1);
		Assert.assertTrue(fs.contains(0));

		fs = dsp.getForwardedField1(1);
		Assert.assertTrue(fs == null);

		fs = dsp.getForwardedField1(2);
		Assert.assertTrue(fs == null);

		fs = dsp.getForwardedField2(0);
		Assert.assertTrue(fs.size() == 1);
		Assert.assertTrue(fs.contains(1));
	}
}