/* | |
* 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. | |
*/ | |
package org.apache.uima.ruta.verbalizer; | |
import static org.junit.Assert.assertEquals; | |
import java.util.ArrayList; | |
import java.util.List; | |
import org.apache.uima.ruta.expression.bool.BooleanNumberExpression; | |
import org.apache.uima.ruta.expression.bool.BooleanTypeExpression; | |
import org.apache.uima.ruta.expression.bool.BooleanVariableExpression; | |
import org.apache.uima.ruta.expression.bool.IBooleanExpression; | |
import org.apache.uima.ruta.expression.bool.SimpleBooleanExpression; | |
import org.apache.uima.ruta.expression.list.BooleanListExpression; | |
import org.apache.uima.ruta.expression.list.BooleanListVariableExpression; | |
import org.apache.uima.ruta.expression.list.NumberListExpression; | |
import org.apache.uima.ruta.expression.list.NumberListVariableExpression; | |
import org.apache.uima.ruta.expression.list.SimpleBooleanListExpression; | |
import org.apache.uima.ruta.expression.list.SimpleNumberListExpression; | |
import org.apache.uima.ruta.expression.list.SimpleStringListExpression; | |
import org.apache.uima.ruta.expression.list.SimpleTypeListExpression; | |
import org.apache.uima.ruta.expression.list.StringListExpression; | |
import org.apache.uima.ruta.expression.list.StringListVariableExpression; | |
import org.apache.uima.ruta.expression.list.TypeListExpression; | |
import org.apache.uima.ruta.expression.list.TypeListVariableExpression; | |
import org.apache.uima.ruta.expression.number.ComposedNumberExpression; | |
import org.apache.uima.ruta.expression.number.INumberExpression; | |
import org.apache.uima.ruta.expression.number.NumberVariableExpression; | |
import org.apache.uima.ruta.expression.number.SimpleNumberExpression; | |
import org.apache.uima.ruta.expression.string.AbstractStringExpression; | |
import org.apache.uima.ruta.expression.string.ComposedStringExpression; | |
import org.apache.uima.ruta.expression.string.IStringExpression; | |
import org.apache.uima.ruta.expression.string.SimpleStringExpression; | |
import org.apache.uima.ruta.expression.string.StringVariableExpression; | |
import org.apache.uima.ruta.expression.type.ITypeExpression; | |
import org.apache.uima.ruta.expression.type.SimpleTypeExpression; | |
import org.apache.uima.ruta.expression.type.TypeVariableExpression; | |
import org.apache.uima.ruta.verbalize.RutaVerbalizer; | |
import org.junit.Test; | |
public class ExpressionVerbalizerTest { | |
@Test | |
public void test() { | |
RutaVerbalizer v = new RutaVerbalizer(); | |
// List<TypeExpression> typeExprList = new ArrayList<TypeExpression>(); | |
// List<StringExpression> stringExprList = new ArrayList<StringExpression>(); | |
// List<RutaExpression> exprList = new ArrayList<RutaExpression>(); | |
// List<INumberExpression> indexes = new ArrayList<INumberExpression>(); | |
// | |
// // typeExprList.add(typeExpr1); | |
// // typeExprList.add(typeExpr2); | |
// | |
// | |
// StringExpression stringExpr = new SimpleStringExpression("string"); | |
// stringExprList.add(stringExpr); | |
// // exprList.add(typeExpr1); | |
// WordTableExpression wordTableExpr = new ReferenceWordTableExpression(var); | |
// WordListExpression wordListExpr = new ReferenceWordListExpression(var); | |
// TypeListExpression typeListExpr = new SimpleTypeListExpression(typeExprList); | |
// StringListExpression stringListExpr = new SimpleStringListExpression(stringExprList); | |
// Map<StringExpression, RutaExpression> stringExprMap = new HashMap<StringExpression, | |
// RutaExpression>(); | |
// Map<StringExpression, INumberExpression> stringExprNumExprMap = new HashMap<StringExpression, | |
// INumberExpression>(); | |
// Map<StringExpression, TypeExpression> stringExprTypeExprMap = new HashMap<StringExpression, | |
// TypeExpression>(); | |
// @SuppressWarnings("rawtypes") | |
// ListExpression listExpr = new SimpleTypeListExpression(typeExprList); | |
// @SuppressWarnings("rawtypes") | |
// List<ListExpression> listExprList = new ArrayList<ListExpression>(); | |
// listExprList.add(listExpr); | |
// stringExprMap.put(stringExpr, stringExpr); | |
// // stringExprNumExprMap.put(stringExpr, numExpr1); | |
// // stringExprTypeExprMap.put(stringExpr, typeExpr1); | |
// // indexes.add(numExpr1); | |
// // indexes.add(numExpr2); | |
String s = null; | |
String var = "anyVar"; | |
ITypeExpression typeExpr1 = new SimpleTypeExpression("Type1"); | |
ITypeExpression typeExpr2 = new TypeVariableExpression("typeVar"); | |
List<INumberExpression> numExprList1 = new ArrayList<INumberExpression>(); | |
List<INumberExpression> numExprList2 = new ArrayList<INumberExpression>(); | |
List<String> opList1 = new ArrayList<String>(); | |
List<String> opList2 = new ArrayList<String>(); | |
INumberExpression numExpr1 = new SimpleNumberExpression(4); | |
INumberExpression numExpr2 = new NumberVariableExpression("numVar"); | |
INumberExpression numExpr3 = new NumberVariableExpression("4.9"); | |
INumberExpression numExpr4 = new NumberVariableExpression("-4"); | |
numExprList1.add(numExpr1); | |
numExprList1.add(numExpr2); | |
opList1.add("+"); | |
opList2.add("*"); | |
INumberExpression numExpr5 = new ComposedNumberExpression(numExprList1, opList1); | |
numExprList2.add(numExpr3); | |
numExprList2.add(numExpr5); | |
INumberExpression numExpr6 = new ComposedNumberExpression(numExprList2, opList2); | |
s = v.verbalize(numExpr1); | |
assertEquals("4", s); | |
s = v.verbalize(numExpr2); | |
assertEquals("numVar", s); | |
s = v.verbalize(numExpr3); | |
assertEquals("4.9", s); | |
s = v.verbalize(numExpr4); | |
assertEquals("-4", s); | |
s = v.verbalize(numExpr5); | |
assertEquals("4 + numVar", s); | |
s = v.verbalize(numExpr6); | |
assertEquals("4.9 * 4 + numVar", s); | |
IBooleanExpression boolExpr1 = new SimpleBooleanExpression(true); | |
IBooleanExpression boolExpr2 = new SimpleBooleanExpression(false); | |
IBooleanExpression boolExpr3 = new BooleanVariableExpression(var); | |
IBooleanExpression boolExpr4 = new BooleanNumberExpression(numExpr1, "==", numExpr2); | |
IBooleanExpression boolExpr5 = new BooleanNumberExpression(numExpr1, "!=", numExpr2); | |
IBooleanExpression boolExpr6 = new BooleanNumberExpression(numExpr1, "<=", numExpr2); | |
IBooleanExpression boolExpr7 = new BooleanNumberExpression(numExpr1, ">=", numExpr2); | |
IBooleanExpression boolExpr8 = new BooleanNumberExpression(numExpr1, "<", numExpr2); | |
IBooleanExpression boolExpr9 = new BooleanNumberExpression(numExpr1, ">", numExpr2); | |
IBooleanExpression boolExpr10 = new BooleanTypeExpression(typeExpr1, "==", typeExpr2); | |
IBooleanExpression boolExpr11 = new BooleanTypeExpression(typeExpr1, "!=", typeExpr2); | |
s = v.verbalize(boolExpr1); | |
assertEquals("true", s); | |
s = v.verbalize(boolExpr2); | |
assertEquals("false", s); | |
s = v.verbalize(boolExpr3); | |
assertEquals("anyVar", s); | |
s = v.verbalize(boolExpr4); | |
assertEquals("4 == numVar", s); | |
s = v.verbalize(boolExpr5); | |
assertEquals("4 != numVar", s); | |
s = v.verbalize(boolExpr6); | |
assertEquals("4 <= numVar", s); | |
s = v.verbalize(boolExpr7); | |
assertEquals("4 >= numVar", s); | |
s = v.verbalize(boolExpr8); | |
assertEquals("4 < numVar", s); | |
s = v.verbalize(boolExpr9); | |
assertEquals("4 > numVar", s); | |
s = v.verbalize(boolExpr10); | |
assertEquals("Type1 == typeVar", s); | |
s = v.verbalize(boolExpr11); | |
assertEquals("Type1 != typeVar", s); | |
List<IStringExpression> stringExprList = new ArrayList<IStringExpression>(); | |
AbstractStringExpression stringExpr1 = new SimpleStringExpression("string"); | |
AbstractStringExpression stringExpr2 = new StringVariableExpression(var); | |
stringExprList.add(stringExpr1); | |
stringExprList.add(stringExpr2); | |
AbstractStringExpression stringExpr3 = new ComposedStringExpression(stringExprList); | |
s = v.verbalize(stringExpr1); | |
assertEquals("\"string\"", s); | |
s = v.verbalize(stringExpr2); | |
assertEquals("anyVar", s); | |
s = v.verbalize(stringExpr3); | |
assertEquals("\"string\" + anyVar", s); | |
StringListExpression sle1 = new SimpleStringListExpression(stringExprList); | |
StringListExpression sle2 = new StringListVariableExpression(var); | |
s = v.verbalize(sle1); | |
assertEquals("{\"string\", anyVar}", s); | |
s = v.verbalize(sle2); | |
assertEquals("anyVar", s); | |
List<IBooleanExpression> boolExprList = new ArrayList<IBooleanExpression>(); | |
boolExprList.add(boolExpr1); | |
boolExprList.add(boolExpr3); | |
BooleanListExpression ble1 = new SimpleBooleanListExpression(boolExprList); | |
BooleanListExpression ble2 = new BooleanListVariableExpression(var); | |
s = v.verbalize(ble1); | |
assertEquals("{true, anyVar}", s); | |
s = v.verbalize(ble2); | |
assertEquals("anyVar", s); | |
List<INumberExpression> numExprList = new ArrayList<INumberExpression>(); | |
numExprList.add(numExpr1); | |
numExprList.add(numExpr3); | |
NumberListExpression nle1 = new SimpleNumberListExpression(numExprList); | |
NumberListExpression nle2 = new NumberListVariableExpression(var); | |
s = v.verbalize(nle1); | |
assertEquals("{4, 4.9}", s); | |
s = v.verbalize(nle2); | |
assertEquals("anyVar", s); | |
List<ITypeExpression> typeExprList = new ArrayList<ITypeExpression>(); | |
typeExprList.add(typeExpr1); | |
typeExprList.add(typeExpr2); | |
TypeListExpression tle1 = new SimpleTypeListExpression(typeExprList); | |
TypeListExpression tle2 = new TypeListVariableExpression(var); | |
s = v.verbalize(tle1); | |
assertEquals("{Type1, typeVar}", s); | |
s = v.verbalize(tle2); | |
assertEquals("anyVar", s); | |
} | |
} |