registries

calculatorpp-core/pom.xml

@@ -30,6 +30,13 @@
             <scope>test</scope>
         </dependency>
 
+        <dependency>
+            <groupId>net.sf.opencsv</groupId>
+            <artifactId>opencsv</artifactId>
+            <version>2.0</version>
+            <scope>test</scope>
+        </dependency>
+
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>

calculatorpp-core/src/test/java/org/solovyev/android/calculator/AbstractCalculatorTest.java

@@ -1,7 +1,5 @@
 package org.solovyev.android.calculator;
 
-import jscl.JsclMathEngine;
-import org.jetbrains.annotations.NotNull;
 import org.mockito.Mockito;
 import org.solovyev.android.calculator.history.CalculatorHistory;
 
@@ -12,21 +10,9 @@ import org.solovyev.android.calculator.history.CalculatorHistory;
  */
 public class AbstractCalculatorTest {
 
-    protected static void staticSetUp() throws Exception {
-        CalculatorLocatorImpl.getInstance().init(new CalculatorImpl(), newCalculatorEngine(), Mockito.mock(CalculatorClipboard.class), Mockito.mock(CalculatorNotifier.class), Mockito.mock(CalculatorHistory.class));
-    }
-
     protected void setUp() throws Exception {
-        CalculatorLocatorImpl.getInstance().init(new CalculatorImpl(), newCalculatorEngine(), Mockito.mock(CalculatorClipboard.class), Mockito.mock(CalculatorNotifier.class), Mockito.mock(CalculatorHistory.class));
+        CalculatorLocatorImpl.getInstance().init(new CalculatorImpl(), CalculatorTestUtils.newCalculatorEngine(), Mockito.mock(CalculatorClipboard.class), Mockito.mock(CalculatorNotifier.class), Mockito.mock(CalculatorHistory.class));
+        CalculatorLocatorImpl.getInstance().getEngine().init();
     }
 
-    @NotNull
-    private static CalculatorEngineImpl newCalculatorEngine() {
-        final CalculatorMathRegistry varsRegistry = Mockito.mock(CalculatorMathRegistry.class);
-        //Mockito.when(varsRegistry.get())
-
-        final CalculatorEngineImpl result = new CalculatorEngineImpl(JsclMathEngine.getInstance(), varsRegistry, Mockito.mock(CalculatorMathRegistry.class), Mockito.mock(CalculatorMathRegistry.class), Mockito.mock(CalculatorMathRegistry.class), null);
-        result.init();
-        return result;
-    }
 }

calculatorpp-core/src/test/java/org/solovyev/android/calculator/CalculatorTestUtils.java

@@ -0,0 +1,33 @@
+package org.solovyev.android.calculator;
+
+import jscl.JsclMathEngine;
+import org.jetbrains.annotations.NotNull;
+import org.mockito.Mockito;
+import org.solovyev.android.calculator.history.CalculatorHistory;
+
+/**
+ * User: serso
+ * Date: 10/7/12
+ * Time: 8:40 PM
+ */
+public class CalculatorTestUtils {
+
+    public static void staticSetUp() throws Exception {
+        CalculatorLocatorImpl.getInstance().init(new CalculatorImpl(), newCalculatorEngine(), Mockito.mock(CalculatorClipboard.class), Mockito.mock(CalculatorNotifier.class), Mockito.mock(CalculatorHistory.class));
+        CalculatorLocatorImpl.getInstance().getEngine().init();
+    }
+
+    @NotNull
+    static CalculatorEngineImpl newCalculatorEngine() {
+        final MathEntityDao mathEntityDao = Mockito.mock(MathEntityDao.class);
+
+        final JsclMathEngine jsclEngine = JsclMathEngine.getInstance();
+
+        final CalculatorVarsRegistry varsRegistry = new CalculatorVarsRegistry(jsclEngine.getConstantsRegistry(), mathEntityDao);
+        final CalculatorFunctionsMathRegistry functionsRegistry = new CalculatorFunctionsMathRegistry(jsclEngine.getFunctionsRegistry(), mathEntityDao);
+        final CalculatorOperatorsMathRegistry operatorsRegistry = new CalculatorOperatorsMathRegistry(jsclEngine.getOperatorsRegistry(), mathEntityDao);
+        final CalculatorPostfixFunctionsRegistry postfixFunctionsRegistry = new CalculatorPostfixFunctionsRegistry(jsclEngine.getPostfixFunctionsRegistry(), mathEntityDao);
+
+        return new CalculatorEngineImpl(jsclEngine, varsRegistry, functionsRegistry, operatorsRegistry, postfixFunctionsRegistry, null);
+    }
+}

calculatorpp-core/src/test/java/org/solovyev/android/calculator/FromJsclSimplifyTextProcessorTest.java

@@ -0,0 +1,71 @@
+package org.solovyev.android.calculator;
+
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.solovyev.android.calculator.model.Var;
+import org.solovyev.android.calculator.text.FromJsclSimplifyTextProcessor;
+
+import java.text.DecimalFormatSymbols;
+
+/**
+ * User: serso
+ * Date: 10/20/11
+ * Time: 3:43 PM
+ */
+public class FromJsclSimplifyTextProcessorTest extends AbstractCalculatorTest {
+
+	@BeforeClass
+	public static void staticSetUp() throws Exception {
+		CalculatorTestUtils.staticSetUp();
+	}
+
+	@Test
+	public void testProcess() throws Exception {
+		FromJsclSimplifyTextProcessor tp = new FromJsclSimplifyTextProcessor();
+		//Assert.assertEquals("(e)", tp.process("(2.718281828459045)"));
+		//Assert.assertEquals("ee", tp.process("2.718281828459045*2.718281828459045"));
+		//Assert.assertEquals("((e)(e))", tp.process("((2.718281828459045)*(2.718281828459045))"));
+		DecimalFormatSymbols decimalGroupSymbols = new DecimalFormatSymbols();
+		decimalGroupSymbols.setGroupingSeparator(' ');
+        CalculatorLocatorImpl.getInstance().getEngine().setDecimalGroupSymbols(decimalGroupSymbols);
+		//Assert.assertEquals("123 456 789e", tp.process("123456789*2.718281828459045"));
+		//Assert.assertEquals("123 456 789e", tp.process("123 456 789 * 2.718281828459045"));
+		//Assert.assertEquals("t11e", tp.process("t11*2.718281828459045"));
+		//Assert.assertEquals("e", tp.process("2.718281828459045"));
+		//Assert.assertEquals("tee", tp.process("t2.718281828459045*2.718281828459045"));
+
+		CalculatorLocatorImpl.getInstance().getEngine().getVarsRegistry().add(new Var.Builder("t2.718281828459045", "2"));
+		CalculatorLocatorImpl.getInstance().getEngine().getVarsRegistry().add(new Var.Builder("t", (String)null));
+		//Assert.assertEquals("t2.718281828459045e", tp.process("t2.718281828459045*2.718281828459045"));
+		//Assert.assertEquals("ee", tp.process("2.718281828459045*2.718281828459045"));
+		Assert.assertEquals("t×", tp.process("t*"));
+		Assert.assertEquals("×t", tp.process("*t"));
+		Assert.assertEquals("t2", tp.process("t*2"));
+		Assert.assertEquals("2t", tp.process("2*t"));
+		CalculatorLocatorImpl.getInstance().getEngine().getVarsRegistry().add(new Var.Builder("t", (String) null));
+		Assert.assertEquals("t×", tp.process("t*"));
+		Assert.assertEquals("×t", tp.process("*t"));
+
+		Assert.assertEquals("t2", tp.process("t*2"));
+		Assert.assertEquals("2t", tp.process("2*t"));
+
+		Assert.assertEquals("t^2×2", tp.process("t^2*2"));
+		Assert.assertEquals("2t^2", tp.process("2*t^2"));
+
+		Assert.assertEquals("t^[2×2t]", tp.process("t^[2*2*t]"));
+		Assert.assertEquals("2t^2[2t]", tp.process("2*t^2[2*t]"));
+
+		CalculatorLocatorImpl.getInstance().getEngine().getVarsRegistry().add(new Var.Builder("k", (String) null));
+		Assert.assertEquals("(t+2k)[k+2t]", tp.process("(t+2*k)*[k+2*t]"));
+		Assert.assertEquals("(te+2k)e[k+2te]", tp.process("(t*e+2*k)*e*[k+2*t*e]"));
+
+
+		Assert.assertEquals("tlog(3)", tp.process("t*log(3)"));
+		Assert.assertEquals("t√(3)", tp.process("t*√(3)"));
+		Assert.assertEquals("20x", tp.process("20*x"));
+		Assert.assertEquals("20x", tp.process("20x"));
+		Assert.assertEquals("2×0x3", tp.process("2*0x3"));
+		Assert.assertEquals("2×0x:3", tp.process("2*0x:3"));
+	}
+}

calculatorpp-core/src/test/java/org/solovyev/android/calculator/jscl/FromJsclNumericTextProcessorTest.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2009-2011. Created by serso aka se.solovyev.
+ * For more information, please, contact se.solovyev@gmail.com
+ * or visit http://se.solovyev.org
+ */
+
+package org.solovyev.android.calculator.jscl;
+
+import jscl.AngleUnit;
+import jscl.JsclMathEngine;
+import jscl.math.Expression;
+import jscl.math.Generic;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.solovyev.android.calculator.AbstractCalculatorTest;
+import org.solovyev.android.calculator.CalculatorTestUtils;
+
+/**
+ * User: serso
+ * Date: 10/18/11
+ * Time: 10:42 PM
+ */
+public class FromJsclNumericTextProcessorTest extends AbstractCalculatorTest {
+
+	@BeforeClass
+	public static void staticSetUp() throws Exception {
+		CalculatorTestUtils.staticSetUp();
+	}
+
+	@Test
+	public void testCreateResultForComplexNumber() throws Exception {
+		final FromJsclNumericTextProcessor cm = new FromJsclNumericTextProcessor();
+
+        final JsclMathEngine me = JsclMathEngine.getInstance();
+        final AngleUnit defaultAngleUnits = me.getAngleUnits();
+
+		Assert.assertEquals("1.22133+23 123i", cm.process(Expression.valueOf("1.22133232+23123*i").numeric()));
+		Assert.assertEquals("1.22133+1.2i", cm.process(Expression.valueOf("1.22133232+1.2*i").numeric()));
+		Assert.assertEquals("1.22133+0i", cm.process(Expression.valueOf("1.22133232+0.000000001*i").numeric()));
+        try {
+            me.setAngleUnits(AngleUnit.rad);
+            Assert.assertEquals("1-0i", cm.process(Expression.valueOf("-(e^(i*π))").numeric()));
+        } finally {
+            me.setAngleUnits(defaultAngleUnits);
+        }
+        Assert.assertEquals("1.22i", cm.process(Expression.valueOf("1.22*i").numeric()));
+		Assert.assertEquals("i", cm.process(Expression.valueOf("i").numeric()));
+		Generic numeric = Expression.valueOf("e^(Π*i)+1").numeric();
+		junit.framework.Assert.assertEquals("0i", cm.process(numeric));
+	}
+}

calculatorpp-core/src/test/java/org/solovyev/android/calculator/math/MathTypeTest.java

@@ -10,6 +10,7 @@ import junit.framework.Assert;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.solovyev.android.calculator.AbstractCalculatorTest;
+import org.solovyev.android.calculator.CalculatorTestUtils;
 
 /**
  * User: serso
@@ -20,7 +21,7 @@ public class MathTypeTest extends AbstractCalculatorTest {
 
 	@BeforeClass
 	public static void staticSetUp() throws Exception {
-        AbstractCalculatorTest.staticSetUp();
+        CalculatorTestUtils.staticSetUp();
 	}
 
 	@Test

calculatorpp-core/src/test/java/org/solovyev/android/calculator/model/AndroidCalculatorEngineTest.java

@@ -0,0 +1,448 @@
+/*
+ * Copyright (c) 2009-2011. Created by serso aka se.solovyev.
+ * For more information, please, contact se.solovyev@gmail.com
+ */
+
+package org.solovyev.android.calculator.model;
+
+import jscl.AngleUnit;
+import jscl.JsclMathEngine;
+import jscl.MathEngine;
+import jscl.NumeralBase;
+import jscl.math.Expression;
+import jscl.math.Generic;
+import jscl.math.function.Constant;
+import jscl.math.function.CustomFunction;
+import jscl.text.ParseException;
+import junit.framework.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.solovyev.android.calculator.CalculatorEvalException;
+import org.solovyev.android.calculator.CalculatorLocatorImpl;
+import org.solovyev.android.calculator.CalculatorTestUtils;
+
+import java.text.DecimalFormatSymbols;
+import java.util.Locale;
+
+import static junit.framework.Assert.fail;
+
+/**
+ * User: serso
+ * Date: 9/17/11
+ * Time: 9:47 PM
+ */
+
+@SuppressWarnings("deprecation")
+public class AndroidCalculatorEngineTest {
+
+	@BeforeClass
+	public static void setUp() throws Exception {
+        CalculatorTestUtils.staticSetUp();
+        CalculatorLocatorImpl.getInstance().getEngine().setPrecision(3);
+	}
+    
+
+	@Test
+	public void testDegrees() throws Exception {
+		final MathEngine cm = CalculatorLocatorImpl.getInstance().getEngine().getMathEngine0();
+
+		final AngleUnit defaultAngleUnit = cm.getAngleUnits();
+		try {
+			cm.setAngleUnits(AngleUnit.rad);
+			cm.setPrecision(3);
+			try {
+				Assert.assertEquals("0.017", cm.evaluate("°"));
+                fail();
+			} catch (ParseException e) {
+
+			}
+
+			Assert.assertEquals("0.017", cm.evaluate( "1°"));
+			Assert.assertEquals("0.349", cm.evaluate( "20.0°"));
+			Assert.assertEquals("0.5", cm.evaluate( "sin(30°)"));
+			Assert.assertEquals("0.524", cm.evaluate( "asin(sin(30°))"));
+			Assert.assertEquals("∂(cos(t), t, t, 1°)", cm.evaluate( "∂(cos(t),t,t,1°)"));
+
+			Assert.assertEquals("∂(cos(t), t, t, 1°)", cm.simplify("∂(cos(t),t,t,1°)"));
+		} finally {
+			cm.setAngleUnits(defaultAngleUnit);
+		}
+	}
+
+/*	@Test
+	public void testLongExecution() throws Exception {
+		final MathEngine cm = CalculatorLocatorImpl.getInstance().getEngine().getMathEngine0();
+
+		try {
+			cm.evaluate( "3^10^10^10");
+			fail();
+		} catch (ParseException e) {
+			if (e.getMessageCode().equals(Messages.msg_3)) {
+
+			} else {
+				System.out.print(e.getCause().getMessage());
+				fail();
+			}
+		}
+
+		try {
+			cm.evaluate("9999999!");
+			fail();
+		} catch (ParseException e) {
+			if (e.getMessageCode().equals(Messages.msg_3)) {
+
+			} else {
+				System.out.print(e.getCause().getMessage());
+				fail();
+			}
+		}
+
+		final long start = System.currentTimeMillis();
+		try {
+			cm.evaluate( "3^10^10^10");
+			fail();
+		} catch (ParseException e) {
+			if (e.getMessage().startsWith("Too long calculation")) {
+				final long end = System.currentTimeMillis();
+				Assert.assertTrue(end - start < 1000);
+			} else {
+				fail();
+			}
+		}
+
+	}*/
+
+	@Test
+	public void testEvaluate() throws Exception {
+		final MathEngine cm = CalculatorLocatorImpl.getInstance().getEngine().getMathEngine0();
+
+		Assert.assertEquals("cos(t)+10%", cm.simplify( "cos(t)+10%"));
+
+		final Generic expression = cm.simplifyGeneric("cos(t)+10%");
+		expression.substitute(new Constant("t"), Expression.valueOf(100d));
+
+		Assert.assertEquals("it", cm.simplify( "it"));
+		Assert.assertEquals("10%", cm.simplify( "10%"));
+		Assert.assertEquals("0", cm.evaluate( "eq(0, 1)"));
+		Assert.assertEquals("1", cm.evaluate( "eq(1, 1)"));
+		Assert.assertEquals("1", cm.evaluate( "eq(  1,   1)"));
+		Assert.assertEquals("1", cm.simplify( "eq(  1,   1)"));
+		Assert.assertEquals("1", cm.evaluate( "lg(10)"));
+		Assert.assertEquals("4", cm.evaluate( "2+2"));
+		final AngleUnit defaultAngleUnit = cm.getAngleUnits();
+		try {
+			cm.setAngleUnits(AngleUnit.rad);
+			Assert.assertEquals("-0.757", cm.evaluate( "sin(4)"));
+			Assert.assertEquals("0.524", cm.evaluate( "asin(0.5)"));
+			Assert.assertEquals("-0.396", cm.evaluate( "sin(4)asin(0.5)"));
+			Assert.assertEquals("-0.56", cm.evaluate( "sin(4)asin(0.5)√(2)"));
+			Assert.assertEquals("-0.56", cm.evaluate( "sin(4)asin(0.5)√(2)"));
+		} finally {
+			cm.setAngleUnits(defaultAngleUnit);
+		}
+		Assert.assertEquals("7.389", cm.evaluate( "e^2"));
+		Assert.assertEquals("7.389", cm.evaluate( "exp(1)^2"));
+		Assert.assertEquals("7.389", cm.evaluate( "exp(2)"));
+		Assert.assertEquals("2+i", cm.evaluate( "2*1+√(-1)"));
+		try {
+			cm.setAngleUnits(AngleUnit.rad);
+			Assert.assertEquals("0.921+Πi", cm.evaluate( "ln(5cosh(38π√(2cos(2))))"));
+			Assert.assertEquals("-3.41+3.41i", cm.evaluate( "(5tan(2i)+2i)/(1-i)"));
+		} finally {
+			cm.setAngleUnits(defaultAngleUnit);
+		}
+		Assert.assertEquals("7.389i", cm.evaluate( "iexp(2)"));
+		Assert.assertEquals("2+7.389i", cm.evaluate( "2+iexp(2)"));
+		Assert.assertEquals("2+7.389i", cm.evaluate( "2+√(-1)exp(2)"));
+		Assert.assertEquals("2-2.5i", cm.evaluate( "2-2.5i"));
+		Assert.assertEquals("-2-2.5i", cm.evaluate( "-2-2.5i"));
+		Assert.assertEquals("-2+2.5i", cm.evaluate( "-2+2.5i"));
+		Assert.assertEquals("-2+2.1i", cm.evaluate( "-2+2.1i"));
+		Assert.assertEquals("-0.1-0.2i", cm.evaluate( "(1-i)/(2+6i)"));
+
+		junit.framework.Assert.assertEquals("24", cm.evaluate( "4!"));
+		junit.framework.Assert.assertEquals("24", cm.evaluate( "(2+2)!"));
+		junit.framework.Assert.assertEquals("120", cm.evaluate( "(2+2+1)!"));
+		junit.framework.Assert.assertEquals("24", cm.evaluate( "(2.0+2.0)!"));
+		junit.framework.Assert.assertEquals("24", cm.evaluate( "4.0!"));
+		junit.framework.Assert.assertEquals("720", cm.evaluate( "(3!)!"));
+		junit.framework.Assert.assertEquals("36", Expression.valueOf("3!^2").numeric().toString());
+		junit.framework.Assert.assertEquals("3", Expression.valueOf("cubic(27)").numeric().toString());
+		try {
+			junit.framework.Assert.assertEquals("√(-1)!", cm.evaluate( "i!"));
+			fail();
+		} catch (ParseException e) {
+		}
+
+		junit.framework.Assert.assertEquals("1", cm.evaluate( "(π/π)!"));
+
+		try {
+			junit.framework.Assert.assertEquals("i", cm.evaluate( "(-1)i!"));
+			fail();
+		} catch (ParseException e) {
+
+		}
+		junit.framework.Assert.assertEquals("24i", cm.evaluate( "4!i"));
+
+		CalculatorLocatorImpl.getInstance().getEngine().getVarsRegistry().add(new Var.Builder("si", 5d));
+
+		try {
+			cm.setAngleUnits(AngleUnit.rad);
+			Assert.assertEquals("0.451", cm.evaluate( "acos(0.8999999999999811)"));
+			Assert.assertEquals("-0.959", cm.evaluate( "sin(5)"));
+			Assert.assertEquals("-4.795", cm.evaluate( "sin(5)si"));
+			Assert.assertEquals("-23.973", cm.evaluate( "sisin(5)si"));
+			Assert.assertEquals("-23.973", cm.evaluate( "si*sin(5)si"));
+			Assert.assertEquals("-3.309", cm.evaluate( "sisin(5si)si"));
+		} finally {
+			cm.setAngleUnits(defaultAngleUnit);
+		}
+
+		CalculatorLocatorImpl.getInstance().getEngine().getVarsRegistry().add(new Var.Builder("s", 1d));
+		Assert.assertEquals("5", cm.evaluate( "si"));
+
+		CalculatorLocatorImpl.getInstance().getEngine().getVarsRegistry().add(new Var.Builder("k", 3.5d));
+		CalculatorLocatorImpl.getInstance().getEngine().getVarsRegistry().add(new Var.Builder("k1", 4d));
+		Assert.assertEquals("4", cm.evaluate( "k11"));
+
+		CalculatorLocatorImpl.getInstance().getEngine().getVarsRegistry().add(new Var.Builder("t", (String) null));
+		Assert.assertEquals("11t", cm.evaluate( "t11"));
+		Assert.assertEquals("11et", cm.evaluate( "t11e"));
+		Assert.assertEquals("∞", cm.evaluate( "∞"));
+		Assert.assertEquals("∞", cm.evaluate( "Infinity"));
+		Assert.assertEquals("11∞t", cm.evaluate( "t11∞"));
+		Assert.assertEquals("-t+t^3", cm.evaluate( "t(t-1)(t+1)"));
+
+		Assert.assertEquals("100", cm.evaluate( "0.1E3"));
+		Assert.assertEquals("3.957", cm.evaluate( "ln(8)lg(8)+ln(8)"));
+
+		Assert.assertEquals("0.933", cm.evaluate( "0x:E/0x:F"));
+
+		try {
+		 	cm.setNumeralBase(NumeralBase.hex);
+			Assert.assertEquals("E/F", cm.evaluate( "0x:E/0x:F"));
+			Assert.assertEquals("E/F", cm.simplify( "0x:E/0x:F"));
+			Assert.assertEquals("E/F", cm.evaluate( "E/F"));
+			Assert.assertEquals("E/F", cm.simplify( "E/F"));
+		} finally {
+			cm.setNumeralBase(NumeralBase.dec);
+		}
+
+		Assert.assertEquals("0", cm.evaluate( "((((((0))))))"));
+		Assert.assertEquals("0", cm.evaluate( "((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))"));
+
+
+		/*	Assert.assertEquals("0.524", cm.evaluate( "30°").getResult());
+		Assert.assertEquals("0.524", cm.evaluate( "(10+20)°").getResult());
+		Assert.assertEquals("1.047", cm.evaluate( "(10+20)°*2").getResult());
+		try {
+			Assert.assertEquals("0.278", cm.evaluate( "30°^2").getResult());
+			junit.framework.Assert.fail();
+		} catch (ParseException e) {
+			if ( !e.getMessage().equals("Power operation after postfix function is currently unsupported!") ) {
+				junit.framework.Assert.fail();
+			}
+		}*//*
+
+*//*		try {
+			cm.setTimeout(5000);
+			Assert.assertEquals("2", cm.evaluate( "2!").getResult());
+		} finally {
+			cm.setTimeout(3000);
+		}*/
+
+		CalculatorLocatorImpl.getInstance().getEngine().getVarsRegistry().add(new Var.Builder("t", (String) null));
+		Assert.assertEquals("2t", cm.simplify( "∂(t^2,t)"));
+		Assert.assertEquals("2t", cm.evaluate( "∂(t^2,t)"));
+		CalculatorLocatorImpl.getInstance().getEngine().getVarsRegistry().add(new Var.Builder("t", "2"));
+		Assert.assertEquals("2t", cm.simplify( "∂(t^2,t)"));
+		Assert.assertEquals("4", cm.evaluate( "∂(t^2,t)"));
+
+		Assert.assertEquals("-x+x*ln(x)", cm.simplify("∫(ln(x), x)"));
+		Assert.assertEquals("-(x-x*ln(x))/(ln(2)+ln(5))", cm.simplify("∫(log(10, x), x)"));
+
+		Assert.assertEquals("∫((ln(2)+ln(5))/ln(x), x)", cm.simplify("∫(ln(10)/ln(x), x)"));
+		Assert.assertEquals("∫(ln(10)/ln(x), x)", Expression.valueOf("∫(log(x, 10), x)").expand().toString());
+		Assert.assertEquals("∫((ln(2)+ln(5))/ln(x), x)", cm.simplify("∫(log(x, 10), x)"));
+	}
+
+	@Test
+	public void testFormatting() throws Exception {
+		final MathEngine ce = CalculatorLocatorImpl.getInstance().getEngine().getMathEngine0();
+
+		Assert.assertEquals("12 345", ce.simplify( "12345"));
+
+	}
+
+	@Test
+	public void testI() throws ParseException, CalculatorEvalException {
+		final MathEngine cm = CalculatorLocatorImpl.getInstance().getEngine().getMathEngine0();
+
+		Assert.assertEquals("-i", cm.evaluate( "i^3"));
+		for (int i = 0; i < 1000; i++) {
+		 	double real = (Math.random()-0.5) * 1000;
+		 	double imag = (Math.random()-0.5) * 1000;
+		 	int exp = (int)(Math.random() * 10);
+
+			final StringBuilder sb = new StringBuilder();
+			sb.append(real);
+			if ( imag > 0 ) {
+				sb.append("+");
+			}
+			sb.append(imag);
+			sb.append("^").append(exp);
+			try {
+				cm.evaluate( sb.toString());
+			} catch (Throwable e) {
+				fail(sb.toString());
+			}
+		}
+	}
+
+	@Test
+	public void testEmptyFunction() throws Exception {
+		final MathEngine cm = CalculatorLocatorImpl.getInstance().getEngine().getMathEngine0();
+		try {
+			cm.evaluate( "cos(cos(cos(cos(acos(acos(acos(acos(acos(acos(acos(acos(cos(cos(cos(cos(cosh(acos(cos(cos(cos(cos(cos(acos(acos(acos(acos(acos(acos(acos(acos(cos(cos(cos(cos(cosh(acos(cos())))))))))))))))))))))))))))))))))))))");
+			Assert.fail();
+		} catch (ParseException e) {
+		}
+		Assert.assertEquals("0.34+1.382i", cm.evaluate( "ln(ln(ln(ln(ln(ln(ln(ln(ln(ln(ln(ln(ln(ln(ln(100)))))))))))))))"));
+		try {
+			cm.evaluate( "cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos())))))))))))))))))))))))))))))))))))");
+			Assert.fail();
+		} catch (ParseException e) {
+		}
+
+		final AngleUnit defaultAngleUnit = cm.getAngleUnits();
+		try {
+			cm.setAngleUnits(AngleUnit.rad);
+			Assert.assertEquals("0.739", cm.evaluate( "cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(cos(1))))))))))))))))))))))))))))))))))))"));
+		} finally {
+			cm.setAngleUnits(defaultAngleUnit);
+		}
+
+		CalculatorLocatorImpl.getInstance().getEngine().getVarsRegistry().add(new Var.Builder("si", 5d));
+		Assert.assertEquals("5", cm.evaluate( "si"));
+
+		try {
+			cm.evaluate( "sin");
+			Assert.fail();
+		} catch (ParseException e) {
+		}
+	}
+
+	@Test
+	public void testRounding() throws Exception {
+		final MathEngine cm = CalculatorLocatorImpl.getInstance().getEngine().getMathEngine0();
+
+		try {
+			DecimalFormatSymbols decimalGroupSymbols = new DecimalFormatSymbols(Locale.getDefault());
+			decimalGroupSymbols.setDecimalSeparator('.');
+			decimalGroupSymbols.setGroupingSeparator('\'');
+			cm.setDecimalGroupSymbols(decimalGroupSymbols);
+			cm.setPrecision(2);
+			Assert.assertEquals("12'345'678.9", cm.evaluate( "1.23456789E7"));
+			cm.setPrecision(10);
+			Assert.assertEquals("12'345'678.9", cm.evaluate( "1.23456789E7"));
+			Assert.assertEquals("123'456'789", cm.evaluate( "1.234567890E8"));
+			Assert.assertEquals("1'234'567'890.1", cm.evaluate( "1.2345678901E9"));
+		} finally {
+			cm.setPrecision(3);
+			DecimalFormatSymbols decimalGroupSymbols = new DecimalFormatSymbols(Locale.getDefault());
+			decimalGroupSymbols.setDecimalSeparator('.');
+			decimalGroupSymbols.setGroupingSeparator(JsclMathEngine.GROUPING_SEPARATOR_DEFAULT.charAt(0));
+			cm.setDecimalGroupSymbols(decimalGroupSymbols);
+		}
+	}
+
+	@Test
+	public void testComparisonFunction() throws Exception {
+		final MathEngine cm = CalculatorLocatorImpl.getInstance().getEngine().getMathEngine0();
+
+		Assert.assertEquals("0", cm.evaluate( "eq(0, 1)"));
+		Assert.assertEquals("1", cm.evaluate( "eq(1, 1)"));
+		Assert.assertEquals("1", cm.evaluate( "eq(1, 1.0)"));
+		Assert.assertEquals("0", cm.evaluate( "eq(1, 1.000000000000001)"));
+		Assert.assertEquals("0", cm.evaluate( "eq(1, 0)"));
+
+		Assert.assertEquals("1", cm.evaluate( "lt(0, 1)"));
+		Assert.assertEquals("0", cm.evaluate( "lt(1, 1)"));
+		Assert.assertEquals("0", cm.evaluate( "lt(1, 0)"));
+
+		Assert.assertEquals("0", cm.evaluate( "gt(0, 1)"));
+		Assert.assertEquals("0", cm.evaluate( "gt(1, 1)"));
+		Assert.assertEquals("1", cm.evaluate( "gt(1, 0)"));
+
+		Assert.assertEquals("1", cm.evaluate( "ne(0, 1)"));
+		Assert.assertEquals("0", cm.evaluate( "ne(1, 1)"));
+		Assert.assertEquals("1", cm.evaluate( "ne(1, 0)"));
+
+		Assert.assertEquals("1", cm.evaluate( "le(0, 1)"));
+		Assert.assertEquals("1", cm.evaluate( "le(1, 1)"));
+		Assert.assertEquals("0", cm.evaluate( "le(1, 0)"));
+
+		Assert.assertEquals("0", cm.evaluate( "ge(0, 1)"));
+		Assert.assertEquals("1", cm.evaluate( "ge(1, 1)"));
+		Assert.assertEquals("1", cm.evaluate( "ge(1, 0)"));
+
+		Assert.assertEquals("0", cm.evaluate( "ap(0, 1)"));
+		Assert.assertEquals("1", cm.evaluate( "ap(1, 1)"));
+		//Assert.assertEquals("1", cm.evaluate( "ap(1, 1.000000000000001)").getResult());
+		Assert.assertEquals("0", cm.evaluate( "ap(1, 0)"));
+
+	}
+
+
+	@Test
+	public void testNumeralSystems() throws Exception {
+		final MathEngine cm = CalculatorLocatorImpl.getInstance().getEngine().getMathEngine0();
+
+		Assert.assertEquals("11 259 375", cm.evaluate( "0x:ABCDEF"));
+		Assert.assertEquals("30 606 154.462", cm.evaluate( "0x:ABCDEF*e"));
+		Assert.assertEquals("30 606 154.462", cm.evaluate( "e*0x:ABCDEF"));
+		Assert.assertEquals("e", cm.evaluate( "e*0x:ABCDEF/0x:ABCDEF"));
+		Assert.assertEquals("30 606 154.462", cm.evaluate( "0x:ABCDEF*e*0x:ABCDEF/0x:ABCDEF"));
+		Assert.assertEquals("30 606 154.462", cm.evaluate( "c+0x:ABCDEF*e*0x:ABCDEF/0x:ABCDEF-c+0x:C-0x:C"));
+		Assert.assertEquals("1 446 257 064 651.832", cm.evaluate( "28*28 * sin(28) - 0b:1101 + √(28) + exp ( 28) "));
+		Assert.assertEquals("13", cm.evaluate( "0b:1101"));
+
+		try {
+			cm.evaluate( "0b:π");
+			Assert.fail();
+		} catch (ParseException e) {
+			// ok
+		}
+
+		final NumeralBase defaultNumeralBase = cm.getNumeralBase();
+		try{
+			cm.setNumeralBase(NumeralBase.bin);
+			Assert.assertEquals("101", cm.evaluate( "10+11"));
+			Assert.assertEquals("10/11", cm.evaluate( "10/11"));
+
+			cm.setNumeralBase(NumeralBase.hex);
+			Assert.assertEquals("63 7B", cm.evaluate( "56CE+CAD"));
+			Assert.assertEquals("E", cm.evaluate( "E"));
+		} finally {
+			cm.setNumeralBase(defaultNumeralBase);
+		}
+	}
+
+	@Test
+	public void testLog() throws Exception {
+		final MathEngine cm = CalculatorLocatorImpl.getInstance().getEngine().getMathEngine0();
+
+		Assert.assertEquals("∞", Expression.valueOf("1/0").numeric().toString());
+		Assert.assertEquals("∞", Expression.valueOf("ln(10)/ln(1)").numeric().toString());
+
+		// logarithm
+		Assert.assertEquals("ln(x)/ln(base)", ((CustomFunction) cm.getFunctionsRegistry().get("log")).getContent());
+		Assert.assertEquals("∞", cm.evaluate( "log(1, 10)"));
+		Assert.assertEquals("3.322", cm.evaluate( "log(2, 10)"));
+		Assert.assertEquals("1.431", cm.evaluate( "log(5, 10)"));
+		Assert.assertEquals("0.96", cm.evaluate( "log(11, 10)"));
+		Assert.assertEquals("1/(bln(a))", cm.simplify( "∂(log(a, b), b)"));
+		Assert.assertEquals("-ln(b)/(aln(a)^2)", cm.simplify( "∂(log(a, b), a)"));
+
+	}
+}

calculatorpp-core/src/test/java/org/solovyev/android/calculator/model/NumeralBaseTest.java

@@ -0,0 +1,145 @@
+package org.solovyev.android.calculator.model;
+
+import au.com.bytecode.opencsv.CSVReader;
+import jscl.JsclMathEngine;
+import jscl.MathEngine;
+import jscl.math.Expression;
+import jscl.text.ParseException;
+import jscl.util.ExpressionGeneratorWithInput;
+import org.jetbrains.annotations.NotNull;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.solovyev.android.calculator.*;
+import org.solovyev.common.Converter;
+
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * User: serso
+ * Date: 12/14/11
+ * Time: 4:16 PM
+ */
+public class NumeralBaseTest extends AbstractCalculatorTest {
+
+	@BeforeClass
+	public static void staticSetUp() throws Exception {
+		CalculatorTestUtils.staticSetUp();
+        CalculatorLocatorImpl.getInstance().getEngine().setPrecision(3);
+	}
+
+	@Test
+	public void testConversion() throws Exception {
+		CSVReader reader = null;
+		try {
+			final MathEngine me = JsclMathEngine.getInstance();
+
+			reader = new CSVReader(new InputStreamReader(NumeralBaseTest.class.getResourceAsStream("/org/solovyev/android/calculator/model/nb_table.csv")), '\t');
+
+			// skip first line
+			reader.readNext();
+
+			String[] line = reader.readNext();
+			for (; line != null; line = reader.readNext()) {
+				testExpression(line, new DummyExpression());
+				testExpression(line, new Expression1());
+				testExpression(line, new Expression2());
+				testExpression(line, new Expression3());
+
+				final String dec = line[0].toUpperCase();
+				final String hex = "0x:" + line[1].toUpperCase();
+				final String bin = "0b:" + line[2].toUpperCase();
+
+				final List<String> input = new ArrayList<String>();
+				input.add(dec);
+				input.add(hex);
+				input.add(bin);
+
+				//System.out.println("Dec: " + dec);
+				//System.out.println("Hex: " + hex);
+				//System.out.println("Bin: " + bin);
+
+				final ExpressionGeneratorWithInput eg = new ExpressionGeneratorWithInput(input, 20);
+				final List<String> expressions = eg.generate();
+
+				final String decExpression = expressions.get(0);
+				final String hexExpression = expressions.get(1);
+				final String binExpression = expressions.get(2);
+
+				//System.out.println("Dec expression: " + decExpression);
+				//System.out.println("Hex expression: " + hexExpression);
+				//System.out.println("Bin expression: " + binExpression);
+
+				final String decResult = Expression.valueOf(decExpression).numeric().toString();
+				//System.out.println("Dec result: " + decResult);
+
+				final String hexResult = Expression.valueOf(hexExpression).numeric().toString();
+				//System.out.println("Hex result: " + hexResult);
+
+				final String binResult = Expression.valueOf(binExpression).numeric().toString();
+				//System.out.println("Bin result: " + binResult);
+
+				Assert.assertEquals("dec-hex: " + decExpression + " : " + hexExpression, decResult, hexResult);
+				Assert.assertEquals("dec-bin: " + decExpression + " : " + binExpression, decResult, binResult);
+			}
+		} finally {
+			if (reader != null) {
+				reader.close();
+			}
+		}
+	}
+
+	public static void testExpression(@NotNull String[] line, @NotNull Converter<String, String> converter) throws ParseException, CalculatorEvalException, CalculatorParseException {
+		final String dec = line[0].toUpperCase();
+		final String hex = "0x:" + line[1].toUpperCase();
+		final String bin = "0b:" + line[2].toUpperCase();
+
+		final String decExpression = converter.convert(dec);
+		final String decResult = CalculatorLocatorImpl.getInstance().getEngine().getMathEngine().evaluate(decExpression);
+		final String hexExpression = converter.convert(hex);
+		final String hexResult = CalculatorLocatorImpl.getInstance().getEngine().getMathEngine().evaluate(hexExpression);
+		final String binExpression = converter.convert(bin);
+		final String binResult = CalculatorLocatorImpl.getInstance().getEngine().getMathEngine().evaluate(binExpression);
+
+		Assert.assertEquals("dec-hex: " + decExpression + " : " + hexExpression, decResult, hexResult);
+		Assert.assertEquals("dec-bin: " + decExpression + " : " + binExpression, decResult, binResult);
+	}
+
+	private static class DummyExpression implements Converter<String, String> {
+
+		@NotNull
+		@Override
+		public String convert(@NotNull String s) {
+			return s;
+		}
+	}
+
+	private static class Expression1 implements Converter<String, String> {
+
+		@NotNull
+		@Override
+		public String convert(@NotNull String s) {
+			return s + "*" + s;
+		}
+	}
+
+	private static class Expression2 implements Converter<String, String> {
+
+		@NotNull
+		@Override
+		public String convert(@NotNull String s) {
+			return s + "*" + s + " * sin(" + s + ") - 0b:1101";
+		}
+	}
+
+	private static class Expression3 implements Converter<String, String> {
+
+		@NotNull
+		@Override
+		public String convert(@NotNull String s) {
+			return s + "*" + s + " * sin(" + s + ") - 0b:1101 + √(" + s + ") + exp ( " + s + ")";
+		}
+	}
+}

calculatorpp-core/src/test/java/org/solovyev/android/calculator/model/ToJsclTextProcessorTest.java

@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2009-2011. Created by serso aka se.solovyev.
+ * For more information, please, contact se.solovyev@gmail.com
+ * or visit http://se.solovyev.org
+ */
+
+package org.solovyev.android.calculator.model;
+
+import jscl.JsclMathEngine;
+import jscl.NumeralBase;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.solovyev.android.calculator.*;
+import org.solovyev.android.calculator.text.TextProcessor;
+
+/**
+ * User: serso
+ * Date: 9/26/11
+ * Time: 12:13 PM
+ */
+public class ToJsclTextProcessorTest extends AbstractCalculatorTest {
+
+	@BeforeClass
+	public static void staticSetUp() throws Exception {
+        CalculatorTestUtils.staticSetUp();
+	}
+
+	@Test
+	public void testSpecialCases() throws CalculatorParseException {
+		final TextProcessor<PreparedExpression, String> preprocessor = ToJsclTextProcessor.getInstance();
+		Assert.assertEquals( "3^E10", preprocessor.process("3^E10").toString());
+	}
+
+	@Test
+	public void testProcess() throws Exception {
+		final TextProcessor<PreparedExpression, String> preprocessor = ToJsclTextProcessor.getInstance();
+
+		Assert.assertEquals( "", preprocessor.process("").toString());
+		Assert.assertEquals( "()", preprocessor.process("[]").toString());
+		Assert.assertEquals( "()*()", preprocessor.process("[][]").toString());
+		Assert.assertEquals( "()*(1)", preprocessor.process("[][1]").toString());
+		Assert.assertEquals( "(0)*(1)", preprocessor.process("[0][1]").toString());
+		Assert.assertEquals( "(0)*(1E)", preprocessor.process("[0][1E]").toString());
+		Assert.assertEquals( "(0)*(1E1)", preprocessor.process("[0][1E1]").toString());
+		Assert.assertEquals( "(0)*(1E-1)", preprocessor.process("[0][1E-1]").toString());
+		Assert.assertEquals( "(0)*(1.E-1)", preprocessor.process("[0][1.E-1]").toString());
+		Assert.assertEquals( "(0)*(2*E-1)", preprocessor.process("[0][2*E-1]").toString());
+		Assert.assertEquals( "(0)*ln(1)*(2*E-1)", preprocessor.process("[0]ln(1)[2*E-1]").toString());
+		Assert.assertEquals( "sin(4)*asin(0.5)*√(2)", preprocessor.process("sin(4)asin(0.5)√(2)").toString());
+		Assert.assertEquals( "sin(4)*cos(5)", preprocessor.process("sin(4)cos(5)").toString());
+		Assert.assertEquals( "π*sin(4)*π*cos(√(5))", preprocessor.process("πsin(4)πcos(√(5))").toString());
+		Assert.assertEquals( "π*sin(4)+π*cos(√(5))", preprocessor.process("πsin(4)+πcos(√(5))").toString());
+		Assert.assertEquals( "π*sin(4)+π*cos(√(5+(√(-1))))", preprocessor.process("πsin(4)+πcos(√(5+i))").toString());
+		Assert.assertEquals( "π*sin(4.01)+π*cos(√(5+(√(-1))))", preprocessor.process("πsin(4.01)+πcos(√(5+i))").toString());
+		Assert.assertEquals( "e^π*sin(4.01)+π*cos(√(5+(√(-1))))", preprocessor.process("e^πsin(4.01)+πcos(√(5+i))").toString());
+		Assert.assertEquals( "e^π*sin(4.01)+π*cos(√(5+(√(-1))))E2", preprocessor.process("e^πsin(4.01)+πcos(√(5+i))E2").toString());
+		Assert.assertEquals( "e^π*sin(4.01)+π*cos(√(5+(√(-1))))E-2", preprocessor.process("e^πsin(4.01)+πcos(√(5+i))E-2").toString());
+		Assert.assertEquals( "E2", preprocessor.process("E2").toString());
+		Assert.assertEquals( "E-2", preprocessor.process("E-2").toString());
+		Assert.assertEquals( "E-1/2", preprocessor.process("E-1/2").toString());
+		Assert.assertEquals( "E-1.2", preprocessor.process("E-1.2").toString());
+		Assert.assertEquals( "E+1.2", preprocessor.process("E+1.2").toString());
+		Assert.assertEquals( "E(-1.2)", preprocessor.process("E(-1.2)").toString());
+		Assert.assertEquals( "EE", preprocessor.process("EE").toString());
+
+		try {
+			CalculatorLocatorImpl.getInstance().getEngine().setNumeralBase(NumeralBase.hex);
+			Assert.assertEquals( "22F*exp(F)", preprocessor.process("22Fexp(F)").toString());
+		} finally {
+			CalculatorLocatorImpl.getInstance().getEngine().setNumeralBase(NumeralBase.dec);
+		}
+		Assert.assertEquals( "0x:ABCDEF", preprocessor.process("0x:ABCDEF").toString());
+		Assert.assertEquals( "0x:ABCDEF", preprocessor.process("0x:A BC DEF").toString());
+		Assert.assertEquals( "0x:ABCDEF", preprocessor.process("0x:A BC                           DEF").toString());
+		Assert.assertEquals( "0x:ABCDEF*0*x", preprocessor.process("0x:A BC DEF*0x").toString());
+		Assert.assertEquals( "0x:ABCDEF001*0*x", preprocessor.process("0x:A BC DEF001*0x").toString());
+		Assert.assertEquals( "0x:ABCDEF001*0*c", preprocessor.process("0x:A BC DEF001*0c").toString());
+		Assert.assertEquals( "0x:ABCDEF001*c", preprocessor.process("0x:A BC DEF001*c").toString());
+		Assert.assertEquals( "0b:1101", preprocessor.process("0b:1101").toString());
+		Assert.assertEquals( "0x:1C", preprocessor.process("0x:1C").toString());
+		Assert.assertEquals( "0x:1C", preprocessor.process(" 0x:1C").toString());
+		Assert.assertEquals( "0x:1C*0x:1C*sin(0x:1C)-0b:1101+√(0x:1C)+exp(0x:1C)", preprocessor.process("0x:1C*0x:1C * sin(0x:1C) - 0b:1101 + √(0x:1C) + exp ( 0x:1C)").toString());
+		Assert.assertEquals( "0x:1C*0x:1C*sin(0x:1C)-0b:1101+√(0x:1C)+exp(0x:1C)", preprocessor.process("0x:1C*0x:1C * sin(0x:1C) - 0b:1101 + √(0x:1C) + exp ( 0x:1C)").toString());
+
+		try {
+			preprocessor.process("ln()");
+			Assert.fail();
+		} catch (CalculatorParseException e) {
+		}
+		try {
+			preprocessor.process("ln()ln()");
+			Assert.fail();
+		} catch (CalculatorParseException e) {
+		}
+
+		try {
+			preprocessor.process("eln()eln()ln()ln()ln()e");
+			Assert.fail();
+		} catch (CalculatorParseException e) {
+		}
+
+		try {
+			preprocessor.process("ln(ln(ln(ln(ln(ln(ln(ln(ln(ln(ln(ln(ln(ln(ln()))))))))))))))");
+			Assert.fail();
+		} catch (CalculatorParseException e) {
+		}
+
+		try {
+			preprocessor.process("cos(cos(cos(cos(acos(acos(acos(acos(acos(acos(acos(acos(cos(cos(cos(cos(cosh(acos(cos(cos(cos(cos(cos(acos(acos(acos(acos(acos(acos(acos(acos(cos(cos(cos(cos(cosh(acos(cos())))))))))))))))))))))))))))))))))))))");
+			Assert.fail();
+		} catch (CalculatorParseException e) {
+		}
+	}
+
+	@Test
+	public void testDegrees() throws Exception {
+		final TextProcessor<PreparedExpression, String> preprocessor = ToJsclTextProcessor.getInstance();
+
+		Assert.assertEquals( "", preprocessor.process("").toString());
+	/*	try {
+			Assert.assertEquals( "π/180", preprocessor.process("°").toString());
+		} catch (ParseException e) {
+			if ( !e.getMessage().startsWith("Could not find start of prefix") ){
+				junit.framework.Assert.fail();
+			}
+		}
+		Assert.assertEquals( "1*π/180", preprocessor.process("1°").toString());
+		Assert.assertEquals( "20.0*π/180", preprocessor.process("20.0°").toString());
+		Assert.assertEquals( "sin(30*π/180)", preprocessor.process("sin(30°)").toString());
+		Assert.assertEquals( "asin(sin(π/6))*π/180", preprocessor.process("asin(sin(π/6))°").toString());
+		Assert.assertEquals( "1*π/180*sin(1)", preprocessor.process("1°sin(1)").toString());
+		try {
+			Assert.assertEquals( "1*π/180^sin(1)", preprocessor.process("1°^sin(1)").toString());
+			junit.framework.Assert.fail();
+		} catch (ParseException e) {
+			if ( !e.getMessage().equals("Power operation after postfix function is currently unsupported!") ) {
+				junit.framework.Assert.fail();
+			}
+		}*/
+
+	}
+
+	@Test
+	public void testPostfixFunction() throws Exception {
+	}
+
+	@Test
+	public void testNumeralBases() throws Exception {
+		final TextProcessor<PreparedExpression, String> processor = ToJsclTextProcessor.getInstance();
+
+		final NumeralBase defaultNumeralBase = JsclMathEngine.getInstance().getNumeralBase();
+		try{
+			JsclMathEngine.getInstance().setNumeralBase(NumeralBase.bin);
+			Assert.assertEquals("101", JsclMathEngine.getInstance().evaluate("10+11"));
+
+			JsclMathEngine.getInstance().setNumeralBase(NumeralBase.hex);
+			Assert.assertEquals("56CE+CAD", processor.process("56CE+CAD").getExpression());
+		} finally {
+			JsclMathEngine.getInstance().setNumeralBase(defaultNumeralBase);
+		}
+	}
+}

calculatorpp-core/src/test/resources/org/solovyev/android/calculator/model/nb_table.csv

@@ -0,0 +1,257 @@
+dec	hex	bin
+0	0	0
+1	1	1
+2	2	10
+3	3	11
+4	4	100
+5	5	101
+6	6	110
+7	7	111
+8	8	1000
+9	9	1001
+10	a	1010
+11	b	1011
+12	c	1100
+13	d	1101
+14	e	1110
+15	f	1111
+16	10	10000
+17	11	10001
+18	12	10010
+19	13	10011
+20	14	10100
+21	15	10101
+22	16	10110
+23	17	10111
+24	18	11000
+25	19	11001
+26	1a	11010
+27	1b	11011
+28	1c	11100
+29	1d	11101
+30	1e	11110
+31	1f	11111
+32	20	100000
+33	21	100001
+34	22	100010
+35	23	100011
+36	24	100100
+37	25	100101
+38	26	100110
+39	27	100111
+40	28	101000
+41	29	101001
+42	2a	101010
+43	2b	101011
+44	2c	101100
+45	2d	101101
+46	2e	101110
+47	2f	101111
+48	30	110000
+49	31	110001
+50	32	110010
+51	33	110011
+52	34	110100
+53	35	110101
+54	36	110110
+55	37	110111
+56	38	111000
+57	39	111001
+58	3a	111010
+59	3b	111011
+60	3c	111100
+61	3d	111101
+62	3e	111110
+63	3f	111111
+64	40	1000000
+65	41	1000001
+66	42	1000010
+67	43	1000011
+68	44	1000100
+69	45	1000101
+70	46	1000110
+71	47	1000111
+72	48	1001000
+73	49	1001001
+74	4a	1001010
+75	4b	1001011
+76	4c	1001100
+77	4d	1001101
+78	4e	1001110
+79	4f	1001111
+80	50	1010000
+81	51	1010001
+82	52	1010010
+83	53	1010011
+84	54	1010100
+85	55	1010101
+86	56	1010110
+87	57	1010111
+88	58	1011000
+89	59	1011001
+90	5a	1011010
+91	5b	1011011
+92	5c	1011100
+93	5d	1011101
+94	5e	1011110
+95	5f	1011111
+96	60	1100000
+97	61	1100001
+98	62	1100010
+99	63	1100011
+100	64	1100100
+101	65	1100101
+102	66	1100110
+103	67	1100111
+104	68	1101000
+105	69	1101001
+106	6a	1101010
+107	6b	1101011
+108	6c	1101100
+109	6d	1101101
+110	6e	1101110
+111	6f	1101111
+112	70	1110000
+113	71	1110001
+114	72	1110010
+115	73	1110011
+116	74	1110100
+117	75	1110101
+118	76	1110110
+119	77	1110111
+120	78	1111000
+121	79	1111001
+122	7a	1111010
+123	7b	1111011
+124	7c	1111100
+125	7d	1111101
+126	7e	1111110
+127	7f	1111111
+128	80	10000000
+129	81	10000001
+130	82	10000010
+131	83	10000011
+132	84	10000100
+133	85	10000101
+134	86	10000110
+135	87	10000111
+136	88	10001000
+137	89	10001001
+138	8a	10001010
+139	8b	10001011
+140	8c	10001100
+141	8d	10001101
+142	8e	10001110
+143	8f	10001111
+144	90	10010000
+145	91	10010001
+146	92	10010010
+147	93	10010011
+148	94	10010100
+149	95	10010101
+150	96	10010110
+151	97	10010111
+152	98	10011000
+153	99	10011001
+154	9a	10011010
+155	9b	10011011
+156	9c	10011100
+157	9d	10011101
+158	9e	10011110
+159	9f	10011111
+160	a0	10100000
+161	a1	10100001
+162	a2	10100010
+163	a3	10100011
+164	a4	10100100
+165	a5	10100101
+166	a6	10100110
+167	a7	10100111
+168	a8	10101000
+169	a9	10101001
+170	aa	10101010
+171	ab	10101011
+172	ac	10101100
+173	ad	10101101
+174	ae	10101110
+175	af	10101111
+176	b0	10110000
+177	b1	10110001
+178	b2	10110010
+179	b3	10110011
+180	b4	10110100
+181	b5	10110101
+182	b6	10110110
+183	b7	10110111
+184	b8	10111000
+185	b9	10111001
+186	ba	10111010
+187	bb	10111011
+188	bc	10111100
+189	bd	10111101
+190	be	10111110
+191	bf	10111111
+192	c0	11000000
+193	c1	11000001
+194	c2	11000010
+195	c3	11000011
+196	c4	11000100
+197	c5	11000101
+198	c6	11000110
+199	c7	11000111
+200	c8	11001000
+201	c9	11001001
+202	ca	11001010
+203	cb	11001011
+204	cc	11001100
+205	cd	11001101
+206	ce	11001110
+207	cf	11001111
+208	d0	11010000
+209	d1	11010001
+210	d2	11010010
+211	d3	11010011
+212	d4	11010100
+213	d5	11010101
+214	d6	11010110
+215	d7	11010111
+216	d8	11011000
+217	d9	11011001
+218	da	11011010
+219	db	11011011
+220	dc	11011100
+221	dd	11011101
+222	de	11011110
+223	df	11011111
+224	e0	11100000
+225	e1	11100001
+226	e2	11100010
+227	e3	11100011
+228	e4	11100100
+229	e5	11100101
+230	e6	11100110
+231	e7	11100111
+232	e8	11101000
+233	e9	11101001
+234	ea	11101010
+235	eb	11101011
+236	ec	11101100
+237	ed	11101101
+238	ee	11101110
+239	ef	11101111
+240	f0	11110000
+241	f1	11110001
+242	f2	11110010
+243	f3	11110011
+244	f4	11110100
+245	f5	11110101
+246	f6	11110110
+247	f7	11110111
+248	f8	11111000
+249	f9	11111001
+250	fa	11111010
+251	fb	11111011
+252	fc	11111100
+253	fd	11111101
+254	fe	11111110
+255	ff	11111111