FunctionTest (Mondrian OLAP Engine, version 3.11.0.0-353)

java.lang.Object
- junit.framework.Assert
- - junit.framework.TestCase
  - - mondrian.test.FoodMartTestCase
    - - mondrian.olap.fun.FunctionTest

All Implemented Interfaces:

junit.framework.Test
```
public class FunctionTest
extends FoodMartTestCase
```
FunctionTest tests the functions defined in BuiltinFunTable.

Author:

gjohnson

Field Summary
- Fields inherited from class mondrian.test.FoodMartTestCase
  propSaver

Constructor Summary

Constructors
Constructor and Description

FunctionTest()
Creates a FunctionTest.

FunctionTest(String s)
Creates a FuncionTest with an explicit name.

Constructors
Constructor and Description
`FunctionTest()` Creates a FunctionTest.
`FunctionTest(String s)` Creates a FuncionTest with an explicit name.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`_testLinRegAll()` Tests all of the linear regression functions, as suggested by a Microsoft knowledge base article.
`void`	`_testLinRegR2()`
`void`	`_testLinRegVariance()`
`void`	`_testParallelPeriodThrowsException()`
`void`	`_testRank3Huge()` As `testRankHuge()`, but for the 3-argument form of the `RANK` function.
`void`	`_testValidMeasureNonEmpty()`
`void`	`assertAxisCompilesTo(String expr, String expectedCalc)` Compiles a set expression, and asserts that the program looks as expected.
`void`	`assertExprCompilesTo(String expr, String expectedCalc)` Compiles a scalar expression, and asserts that the program looks as expected.
`void`	`assertExprReturns(String expr, double expected, double delta)` Executes a scalar expression, and asserts that the result is within delta of the expected result.
`void`	`assertExprReturns(String expr, String expected)` Executes a scalar expression, and asserts that the result is as expected.
`void`	`testAddCalculatedMembers()`
`void`	`testAggregate()`
`void`	`testAggregate2()`
`void`	`testAggregate2AllMembers()`
`void`	`testAggregateDepends()`
`void`	`testAggregateToSimulateCompoundSlicer()`
`void`	`testAggregateWithIIF()`
`void`	`testAll()`
`void`	`testAll2()`
`void`	`testAll5()`
`void`	`testAllMembers()`
`void`	`testAncestor()`
`void`	`testAncestorAllLevel()`
`void`	`testAncestorDepends()`
`void`	`testAncestorHigher()`
`void`	`testAncestorNumeric()`
`void`	`testAncestors()`
`void`	`testAncestorSameLevel()`
`void`	`testAncestorWithHiddenParent()`
`void`	`testAncestorWrongHierarchy()`
`void`	`testAnd()`
`void`	`testAnd2()`
`void`	`testAs()` Tests the AS operator, that gives an expression an alias.
`void`	`testAs2()`
`void`	`testAscendants()`
`void`	`testAscendantsAll()`
`void`	`testAscendantsNull()`
`void`	`testAvg()`
`void`	`testBasic()`
`void`	`testBasic2()`
`void`	`testBasic5()`
`void`	`testBasic9()`
`void`	`testBottomCount()`
`void`	`testBottomPercent()`
`void`	`testBottomSum()`
`void`	`testBrokenContextBug()`
`void`	`testBug1881739()`
`void`	`testBug714707()`
`void`	`testBug715177()`
`void`	`testBug715177c()`
`void`	`testCache()`
`void`	`testCalculatedChild()`
`void`	`testCalculatedChildOnMemberWithNoChildren()`
`void`	`testCalculatedChildOnNullMember()`
`void`	`testCalculatedChildUsingItem()`
`void`	`testCaseMatch()`
`void`	`testCaseMatchElse()`
`void`	`testCaseMatchNoElse()`
`void`	`testCaseTestMatch()`
`void`	`testCaseTestMatchElse()`
`void`	`testCaseTestMatchNoElse()`
`void`	`testCaseTestReturnsMemberBug1799391()` Testcase for bug 1799391, "Case Test function throws class cast exception"
`void`	`testCaseTuple()` Testcase for bug MONDRIAN-853, "When using CASE WHEN in a CalculatedMember values are not returned the way expected".
`void`	`testCaseTypeMismatch()`
`void`	`testCast()`
`void`	`testCastBug524()` Testcase for bug MONDRIAN-524, "VB functions: expected primitive type, got java.lang.Object".
`void`	`testClosingPeriod()`
`void`	`testClosingPeriodBelow()`
`void`	`testClosingPeriodLevel()`
`void`	`testClosingPeriodLevelNotInTimeFails()`
`void`	`testClosingPeriodMember()`
`void`	`testClosingPeriodMemberLeaf()`
`void`	`testClosingPeriodNoArgs()`
`void`	`testCoalesceEmpty()`
`void`	`testCoalesceEmptyDepends()`
`void`	`testComplexOrExpr()`
`void`	`testComplexQuery()` Executes a query that has a complex parse tree.
`void`	`testCorrelation()`
`void`	`testCount()`
`void`	`testCountExcludeEmpty()`
`void`	`testCountExcludeEmptyNull()` Tests that the 'null' value is regarded as empty, even if the underlying cell has fact table rows.
`void`	`testCountExcludeEmptyOnCubeWithNoCountFacts()` Testcase for bug MONDRIAN-710, "Count with ExcludeEmpty throws an exception when the cube does not have a factCountMeasure".
`void`	`testCountExcludeEmptyOnVirtualCubeWithNoCountFacts()`
`void`	`testCousin1()`
`void`	`testCousin2()`
`void`	`testCousinHigherLevel()`
`void`	`testCousinOverrun()`
`void`	`testCousinSameLevel()`
`void`	`testCousinThreeDown()`
`void`	`testCousinWrongHierarchy()`
`void`	`testCovariance()`
`void`	`testCovarianceN()`
`void`	`testCrossjoinAsterisk()`
`void`	`testCrossjoinAsteriskAssoc()`
`void`	`testCrossjoinAsteriskInsideBraces()`
`void`	`testCrossJoinAsteriskQuery()`
`void`	`testCrossjoinAsteriskTuple()`
`void`	`testCrossjoinDupDimensionOk()` Tests cases of different hierarchies in the same dimension.
`void`	`testCrossjoinDupHierarchyFails()`
`void`	`testCrossjoinNested()`
`void`	`testCrossjoinOrder()` Test case for bug 1911832, "Exception converting immutable list to array in JDK 1.5".
`void`	`testCrossjoinResolve()` Testcase for bug 1889745, "StackOverflowError while resolving crossjoin".
`void`	`testCrossjoinSingletonTuples()`
`void`	`testCrossjoinSingletonTuplesNested()`
`void`	`testCubeTimeDimensionFails()` Testcase for bug MONDRIAN-296, "Cube getTimeDimension use when Cube has no Time dimension".
`void`	`testCurrentMember()`
`void`	`testCurrentMemberDepends()`
`void`	`testCurrentMemberFromAxis()`
`void`	`testCurrentMemberFromDefaultMember()`
`void`	`testCurrentMemberFromSlicer()`
`void`	`testCurrentMemberInCalcMember()` When evaluating a calculated member, MSOLAP regards that calculated member as the current member of that dimension, so it cycles in this case.
`void`	`testCurrentMemberMultiHierarchy()`
`void`	`testDateParameter()` Testcase for bug MONDRIAN-1050, "MDX Order function fails when using DateTime expression for ordering".
`void`	`testDefaultMember()`
`void`	`testDescendants2ndHier()`
`void`	`testDescendantsDepends()`
`void`	`testDescendantsM()`
`void`	`testDescendantsM0()`
`void`	`testDescendantsM2()`
`void`	`testDescendantsM2Leaves()`
`void`	`testDescendantsM2Self()`
`void`	`testDescendantsMEmptyLeaves()`
`void`	`testDescendantsMEmptyLeavesFail()`
`void`	`testDescendantsMEmptyLeavesFail2()`
`void`	`testDescendantsMFarLeaves()`
`void`	`testDescendantsMFarSelf()`
`void`	`testDescendantsML()`
`void`	`testDescendantsMLAfter()`
`void`	`testDescendantsMLAfterEnd()`
`void`	`testDescendantsMLBefore()`
`void`	`testDescendantsMLBeforeAfter()`
`void`	`testDescendantsMLLeaves()`
`void`	`testDescendantsMLLeavesRagged()`
`void`	`testDescendantsMLSelf()`
`void`	`testDescendantsMLSelfBefore()`
`void`	`testDescendantsMLSelfBeforeAfter()`
`void`	`testDescendantsMNLeaves()`
`void`	`testDescendantsMNY()`
`void`	`testDescendantsParentChild()`
`void`	`testDescendantsParentChildBefore()`
`void`	`testDescendantsParentChildLeaves()`
`void`	`testDescendantsSBA()`
`void`	`testDescendantsSet()`
`void`	`testDescendantsSetEmpty()`
`void`	`testDimensionCaption()`
`void`	`testDimensionDefaultMember()`
`void`	`testDimensionHierarchy()`
`void`	`testDimensionName()`
`void`	`testDimensionsDepends()`
`void`	`testDimensionsNumeric()`
`void`	`testDimensionsString()`
`void`	`testDimensionUniqueName()`
`void`	`testDistinctFourMembers()`
`void`	`testDistinctSomeTuples()`
`void`	`testDistinctThreeMembers()`
`void`	`testDistinctTwoMembers()`
`void`	`testDistinctTwoTuples()`
`void`	`testDivide()`
`void`	`testDividePrecedence()`
`void`	`testDrilldownLevel()`
`void`	`testDrilldownLevelTop()`
`void`	`testDrilldownMember()`
`void`	`testDrilldownMemberEmptyExpr()`
`void`	`testDumpFunctions()` Tests `FunTable.getFunInfoList()`, but more importantly, generates an HTML table of all implemented functions into a file called "functions.html".
`void`	`testEq()`
`void`	`testExcelPi()`
`void`	`testExcelPower()`
`void`	`testExceptCrossjoin()` Tests that Except() successfully removes crossjoined tuples from the axis results.
`void`	`testExceptEmpty()`
`void`	`testExistsMembers2Hierarchies()`
`void`	`testExistsMembersAll()`
`void`	`testExistsMembersLevel2()`
`void`	`testExistsTuples2Dim()`
`void`	`testExistsTuplesAll()`
`void`	`testExistsTuplesDiffDim()`
`void`	`testExistsTuplesLevel2()`
`void`	`testExistsTuplesLevel23()`
`void`	`testExistsWithDefaultNonAllMember()`
`void`	`testExistsWithImplicitAllMember()`
`void`	`testExistsWithMultipleHierarchies()`
`void`	`testExtract()`
`void`	`testFilterCalcSlicer()`
`void`	`testFilterCompound()`
`void`	`testFilterEmpty()`
`void`	`testFilterWithSlicer()` Make sure that slicer is in force when expression is applied on axis, E.g.
`void`	`testFirstChildAll()`
`void`	`testFirstChildFirstInLevel()`
`void`	`testFirstChildOfChildless()`
`void`	`testFirstInLevel()`
`void`	`testFirstInLevel2()`
`void`	`testFirstInLevel5()`
`void`	`testFirstInLevel9()`
`void`	`testFirstSiblingAll()`
`void`	`testFirstSiblingFirstInLevel()`
`void`	`testFirstSiblingLastInLevel()`
`void`	`testFirstSiblingNull()`
`void`	`testFirstSiblingRoot()`
`void`	`testFormatFixed()`
`void`	`testFormatMember()`
`void`	`testFormatVariable()`
`void`	`testGe()`
`void`	`testGenerate()`
`void`	`testGenerateAll()`
`void`	`testGenerateCrossJoin()`
`void`	`testGenerateDepends()`
`void`	`testGenerateNonSet()`
`void`	`testGeneratePlusXtd()` Testcase for bug MONDRIAN-458, "error deducing type of Ytd/Qtd/Mtd functions within Generate".
`void`	`testGenerateString()`
`void`	`testGenerateUnique()`
`void`	`testGenerateUniqueTuple()`
`void`	`testGetCaptionUsingMemberDotCaption()`
`void`	`testGt()`
`void`	`testHead()`
`void`	`testHeadBug()` Test case for bug 2488492, "Union between calc mem and head function throws exception"
`void`	`testHeadDefault()`
`void`	`testHeadEmpty()`
`void`	`testHeadNegative()`
`void`	`testHeadOvershoot()`
`void`	`testHierarchize()`
`void`	`testHierarchizeCrossJoinPost()`
`void`	`testHierarchizeCrossJoinPre()`
`void`	`testHierarchizeExcept()` Testcase for bug MONDRIAN-1043, "Hierarchize with Except sort set members differently than in Mondrian 3.2.1".
`void`	`testHierarchizeOrdinal()` Tests that the Hierarchize function works correctly when applied to a level whose ordering is determined by an 'ordinal' property.
`void`	`testHierarchizePC()`
`void`	`testHierarchizePost()`
`void`	`testHierarchyAll()`
`void`	`testHierarchyCaption()`
`void`	`testHierarchyLevelsString()`
`void`	`testHierarchyLevelsStringFail()`
`void`	`testHierarchyMembers()`
`void`	`testHierarchyName()`
`void`	`testHierarchyUniqueName()`
`void`	`testIIf()`
`void`	`testIIfDimension()`
`void`	`testIifFWithBooleanBooleanAndNumericParameterForReturningTruePart()`
`void`	`testIIfHierarchy()`
`void`	`testIIfLevel()`
`void`	`testIIfMember()`
`void`	`testIIfNumeric()`
`void`	`testIIfSet()`
`void`	`testIifWithBooleanBooleanAndNumericParameterForReturningFalsePart()`
`void`	`testIIFWithBooleanBooleanAndNumericParameterForReturningZero()`
`void`	`testIIfWithNullAndNumber()`
`void`	`testIIfWithStringAndNull()`
`void`	`testInStrFunctionWithEmptyString1()`
`void`	`testInStrFunctionWithEmptyString2()`
`void`	`testInStrFunctionWithValidArguments()`
`void`	`testIntersect()`
`void`	`testIntersectAll()`
`void`	`testIntersectLeftEmpty()`
`void`	`testIntersectRightEmpty()`
`void`	`testIntersectTuples()`
`void`	`testIsDimension()`
`void`	`testIsEmpty()`
`void`	`testIsEmptyQuery()`
`void`	`testIsEmptyWithAggregate()`
`void`	`testIsEmptyWithNull()`
`void`	`testIsHierarchy()`
`void`	`testIsLevel()`
`void`	`testIsMember()`
`void`	`testIsNull()`
`void`	`testIsNumeric()`
`void`	`testIsString()`
`void`	`testIsTuple()`
`void`	`testItemMember()`
`void`	`testItemNull()`
`void`	`testItemTuple()`
`void`	`testLag()`
`void`	`testLagAll()`
`void`	`testLagFirstInLevel()`
`void`	`testLagMinValue()` Tests that Integeer.MIN_VALUE(-2147483648) in Lag is handled correctly.
`void`	`testLagRoot()`
`void`	`testLagRootTooFar()`
`void`	`testLastChild()`
`void`	`testLastChildAll()`
`void`	`testLastChildLastInLevel()`
`void`	`testLastChildOfChildless()`
`void`	`testLastPeriods()`
`void`	`testLastSibling()`
`void`	`testLastSiblingAll()`
`void`	`testLastSiblingFirstInLevel()`
`void`	`testLastSiblingNull()`
`void`	`testLastSiblingRoot()`
`void`	`testLe()`
`void`	`testLead()`
`void`	`testLeadLastInLevel()`
`void`	`testLeadNegative()`
`void`	`testLeadNull()`
`void`	`testLeadZero()`
`void`	`testLeftFunctionWithLengthMoreThanStringLength()`
`void`	`testLeftFunctionWithLengthValueEqualToStringLength()`
`void`	`testLeftFunctionWithLengthValueZero()`
`void`	`testLeftFunctionWithNegativeLength()`
`void`	`testLeftFunctionWithValidArguments()`
`void`	`testLeftFunctionWithZeroLengthString()`
`void`	`testLenFunctionWithAnEmptyString()`
`void`	`testLenFunctionWithNonEmptyString()`
`void`	`testLenFunctionWithNullString()`
`void`	`testLevelCaption()`
`void`	`testLevelDimension()`
`void`	`testLevelMemberExpressions()`
`void`	`testLevelName()`
`void`	`testLevelsNumeric()`
`void`	`testLevelsString()`
`void`	`testLevelsStringFail()`
`void`	`testLevelsTooLarge()`
`void`	`testLevelsTooSmall()`
`void`	`testLevelUniqueName()`
`void`	`testLinRegIntercept()`
`void`	`testLinRegPoint()`
`void`	`testLinRegPointMonth()`
`void`	`testLinRegPointQuarter()`
`void`	`testLinRegSlope()`
`void`	`testLt()`
`void`	`testMax()`
`void`	`testMaxNegative()`
`void`	`testMedian()`
`void`	`testMedian2()`
`void`	`testMemberCaption()`
`void`	`testMemberDimension()`
`void`	`testMemberLevel()`
`void`	`testMemberName()`
`void`	`testMembers()`
`void`	`testMemberUniqueName()`
`void`	`testMemberUniqueNameOfNull()`
`void`	`testMidFunctionWithLengthArgumentLargerThanStringLength()`
`void`	`testMidFunctionWithNegativeLength()`
`void`	`testMidFunctionWithNegativeStartIndex()`
`void`	`testMidFunctionWithoutLength()`
`void`	`testMidFunctionWithStartIndexGreaterThanStringLength()`
`void`	`testMidFunctionWithStartIndexOne()`
`void`	`testMidFunctionWithStartIndexZeroFails()`
`void`	`testMidFunctionWithValidArguments()`
`void`	`testMidFunctionWithZeroLengthStringArgument()`
`void`	`testMin()`
`void`	`testMinTuple()`
`void`	`testMinus_bug1234759()`
`void`	`testMinus()`
`void`	`testMinusAssociativity()`
`void`	`testMod()`
`void`	`testMtd()`
`void`	`testMultiply()`
`void`	`testMultiplyBug774807()` Bug 774807 caused expressions to be mistaken for the crossjoin operator.
`void`	`testMultiplyPrecedence()`
`void`	`testMultiselectCalculations()` Tests behavior where CurrentMember occurs in calculated members and that member is a set.
`void`	`testNamedSetCurrentOrdinalWithCrossjoin()`
`void`	`testNamedSetCurrentOrdinalWithFilter()`
`void`	`testNamedSetCurrentOrdinalWithGenerate()` Tests NamedSet.CurrentOrdinal combined with the Generate function.
`void`	`testNamedSetCurrentOrdinalWithNonNamedSetFails()`
`void`	`testNamedSetCurrentOrdinalWithOrder()` Tests NamedSet.CurrentOrdinal combined with the Order function.
`void`	`testNe()`
`void`	`testNegativeZero()`
`void`	`testNegativeZero1()`
`void`	`testNegativeZeroDivide()`
`void`	`testNegativeZeroMultiply()`
`void`	`testNegativeZeroSubtract()`
`void`	`testNeInfinity()`
`void`	`testNonEmptyCrossJoin()`
`void`	`testNot()`
`void`	`testNotAssociativity()`
`void`	`testNotNot()`
`void`	`testNullInAddition()`
`void`	`testNullInMultiplication()`
`void`	`testNullInSubtraction()`
`void`	`testNullMember()`
`void`	`testNullRange()` tests that a null passed in returns an empty set in range function
`void`	`testNullValue()` Tests use of NULL literal to generate a null cell value.
`void`	`testNumericLiteral()`
`void`	`testOpeningPeriod()`
`void`	`testOpeningPeriodNull()` This tests new NULL functionality exception throwing
`void`	`testOr()`
`void`	`testOr2()`
`void`	`testOrAssociativity1()`
`void`	`testOrAssociativity2()`
`void`	`testOrAssociativity3()`
`void`	`testOrder()`
`void`	`testOrderBug656802()`
`void`	`testOrderBug712702_Original()`
`void`	`testOrderBug712702_Simplified()`
`void`	`testOrderCalc()`
`void`	`testOrderConstant1()`
`void`	`testOrderCrossJoin()`
`void`	`testOrderCrossJoinBreak()`
`void`	`testOrderCrossJoinDesc()`
`void`	`testOrderDepends()`
`void`	`testOrderDesc()`
`void`	`testOrderDiffrentDim()`
`void`	`testOrderEmpty()`
`void`	`testOrderHierarchicalDesc()`
`void`	`testOrderKeyEmpty()`
`void`	`testOrderKeyOne()`
`void`	`testOrderMemberDefaultFlag1()`
`void`	`testOrderMemberDefaultFlag2()`
`void`	`testOrderMemberMemberValueExpHierarchy()`
`void`	`testOrderMemberMemberValueExpNew()`
`void`	`testOrderMemberMemberValueExpNew1()`
`void`	`testOrderMemberMultiKeysMemberValueExp1()`
`void`	`testOrderMemberMultiKeysMemberValueExp2()`
`void`	`testOrderMemberMultiKeysMemberValueExpDepends()`
`void`	`testOrderNonEmpty()` test case for bug # 1797159, Potential MDX Order Non Empty Problem
`void`	`testOrderOne()`
`void`	`testOrderParentsMissing()`
`void`	`testOrderTupleMultiKeys1()`
`void`	`testOrderTupleMultiKeys2()`
`void`	`testOrderTupleMultiKeys3()`
`void`	`testOrderTupleMultiKeyswithVCube()`
`void`	`testOrderTupleSingleKeysNew()`
`void`	`testOrderTupleSingleKeysNew1()`
`void`	`testOrderWithMember()` Verifies that the order function works with a defined member.
`void`	`testOrdinal()`
`void`	`testParallelPeriod()`
`void`	`testParallelPeriodDepends()`
`void`	`testParallelPeriodLevel()`
`void`	`testParallelPeriodLevelLag()`
`void`	`testParallelPeriodMinValue()` Tests that Integeer.MIN_VALUE(-2147483648) does not cause NPE.
`void`	`testParallelperiodOnLevelsString()`
`void`	`testParallelperiodOnStrToMember()`
`void`	`testParallelPeriodWithSlicer()` Tests that ParallelPeriod with Aggregate function works
`void`	`testParent()`
`void`	`testParentPC()`
`void`	`testPercentile()`
`void`	`testPercentileBugMondrian1045()` Testcase for bug MONDRIAN-1045, "When I use the Percentile function it cracks when there's only 1 register".
`void`	`testPeriodsToDate()`
`void`	`testPlus()`
`void`	`testPropertiesExpr()`
`void`	`testPropertiesFilter()`
`void`	`testPropertiesNonExistent()` Tests that non-existent property throws an error.
`void`	`testPropertiesOnDimension()` Test case for bug MONDRIAN-1227, "Properties function does not implicitly convert dimension to member; has documentation typos".
`void`	`testPropertyInCalculatedMember()`
`void`	`testQtd()`
`void`	`testQueryWithoutValidMeasure()`
`void`	`testRange()`
`void`	`testRangeBetweenDifferentLevelsIsError()`
`void`	`testRangeBoundedByAll()`
`void`	`testRangeBoundedByAllLarge()`
`void`	`testRangeBoundedByNull()`
`void`	`testRangeBoundedByNullLarge()`
`void`	`testRangeEndBeforeStart()`
`void`	`testRangeEndBeforeStartLarge()`
`void`	`testRangeLarge()` Large dimensions use a different member reader, therefore need to be tested separately.
`void`	`testRangeStartEqualsEnd()`
`void`	`testRangeStartEqualsEndLarge()`
`void`	`testRank()` Tests the `Rank(member, set)` MDX function.
`void`	`testRankHuge()` Tests a RANK function which is so large that we need to use caching in order to execute it efficiently.
`void`	`testRankMembersWithTiedExpr()`
`void`	`testRankTuplesWithTiedExpr()`
`void`	`testRankWithExpr()`
`void`	`testRankWithExpr2()`
`void`	`testRankWithNulls()` Tests the 3-arg version of the RANK function with a value which returns null within a set of nulls.
`void`	`testSetContainingLevelFails()`
`void`	`testSetItemInt()` Tests the function `<Set>.Item(<Integer>)`.
`void`	`testSetItemString()` Tests the function `<Set>.Item(<String> [,...])`.
`void`	`testSetToStr()`
`void`	`testSiblingsA()`
`void`	`testSiblingsB()`
`void`	`testSiblingsC()`
`void`	`testSiblingsD()`
`void`	`testStdev()`
`void`	`testStdevP()`
`void`	`testString()`
`void`	`testStringConcat()`
`void`	`testStringConcat2()`
`void`	`testStringEquals()`
`void`	`testStringEqualsAssociativity()`
`void`	`testStringEqualsEmpty()`
`void`	`testStringLiteral()`
`void`	`testStringNe()`
`void`	`testStripCalculatedMembers()`
`void`	`testStrToMember()`
`void`	`testStrToMemberFullyQualifiedName()`
`void`	`testStrToMemberIgnoreInvalidMembers()` Testcase for bug MONDRIAN-560, "StrToMember function doesn't use IgnoreInvalidMembers option".
`void`	`testStrToMemberNull()`
`void`	`testStrToMemberUniqueName()`
`void`	`testStrToSet()`
`void`	`testStrToSetDupDimensionsFails()`
`void`	`testStrToSetIgnoreInvalidMembers()`
`void`	`testStrToTuple()`
`void`	`testStrToTupleDepends()`
`void`	`testStrToTupleDuHierarchiesFails()`
`void`	`testStrToTupleDupHierInSameDimensions()`
`void`	`testStrToTupleIgnoreInvalidMembers()`
`void`	`testSubset()`
`void`	`testSubsetDefault()`
`void`	`testSubsetEmpty()`
`void`	`testSubsetNegativeCount()`
`void`	`testSubsetNegativeStart()`
`void`	`testSubsetOvershoot()`
`void`	`testSumNoExp()`
`void`	`testTail()`
`void`	`testTailDefault()`
`void`	`testTailEmpty()`
`void`	`testTailNegative()`
`void`	`testTailOvershoot()`
`void`	`testTime()`
`void`	`testToggleDrillState()`
`void`	`testToggleDrillState2()`
`void`	`testToggleDrillState3()`
`void`	`testToggleDrillStateRecursive()`
`void`	`testToggleDrillStateTuple()`
`void`	`testTopCount()`
`void`	`testTopCountDepends()`
`void`	`testTopCountEmpty()`
`void`	`testTopCountHuge()` Tests TopCount applied to a large result set.
`void`	`testTopCountTuple()`
`void`	`testTopPercent()`
`void`	`testTopPercentCrossjoin()` Tests that TopPercent() operates succesfully on a axis of crossjoined tuples.
`void`	`testTopPercentWithAlias()` This is a test for MONDRIAN-2157
`void`	`testTopSum()`
`void`	`testTopSumEmpty()`
`void`	`testTuple()`
`void`	`testTupleAppliedToUnknownHierarchy()`
`void`	`testTupleArgTypes()` Tests whether the tuple operator can be applied to arguments of various types.
`void`	`testTupleDepends()`
`void`	`testTupleItem()`
`void`	`testTupleNull()`
`void`	`testTupleToStr()`
`void`	`testTwoNullRange()` tests that an exception is thrown if both parameters in a range function are null.
`void`	`testUCaseWithEmptyString()`
`void`	`testUCaseWithNonEmptyString()`
`void`	`testUnaryMinus()`
`void`	`testUnaryMinusMember()`
`void`	`testUnaryMinusPrecedence()`
`void`	`testUnion()`
`void`	`testUnionAll()`
`void`	`testUnionAllTuple()`
`void`	`testUnionEmptyBoth()`
`void`	`testUnionEmptyRight()`
`void`	`testUnionQuery()`
`void`	`testUnionTuple()`
`void`	`testUnionTupleDistinct()`
`void`	`testUnorder()`
`void`	`testValidMeasure()` Tests the `ValidMeasure` function.
`void`	`testValidMeasureCalculatedMemberMeasure()` This is a test for MONDRIAN-2109
`void`	`testValidMeasureDepends()`
`void`	`testValidMeasureNonVirtualCube()`
`void`	`testValidMeasureTupleHasAnotherMember()`
`void`	`testValue()`
`void`	`testVar()`
`void`	`testVarP()`
`void`	`testVbaBasic()`
`void`	`testVbaDateTime()`
`void`	`testVbaExceptions()`
`void`	`testVbaOverloading()`
`void`	`testVisualTotalsAll()` Test case for bug MONDRIAN-615, "VisualTotals doesn't work for the all member".
`void`	`testVisualTotalsBasic()`
`void`	`testVisualTotalsClassCast()` Testcase for bug MONDRIAN-761, "VisualTotalMember cannot be cast to RolapCubeMember".
`void`	`testVisualTotalsConsecutively()`
`void`	`testVisualTotalsCrossjoin()`
`void`	`testVisualTotalsDistinctCountMeasure()` Testcase for bug MONDRIAN-682, "VisualTotals + Distinct-count measure gives wrong results".
`void`	`testVisualTotalsFilterInside()`
`void`	`testVisualTotalsGrandparentsAndOutOfOrder()`
`void`	`testVisualTotalsIntersect()` Tests that members generated by VisualTotals have correct identity.
`void`	`testVisualTotalsLevel()`
`void`	`testVisualTotalsMemberInCalculation()` Testcase for bug MONDRIAN-749, "Cannot use visual totals members in calculations".
`void`	`testVisualTotalsNested()`
`void`	`testVisualTotalsNoPattern()`
`void`	`testVisualTotalsOutOfOrder()`
`void`	`testVisualTotalsWithFilter()`
`void`	`testVisualTotalsWithNamedSetAndPivot()` Test case involving a named set and query pivoted.
`void`	`testVisualTotalsWithNamedSetAndPivotSameAxis()` Testcase for bug MONDRIAN-668, "Intersect should return any VisualTotals members in right-hand set".
`void`	`testVisualTotalsWithNamedSetOfTuples()` Testcase for bug MONDRIAN-678, "VisualTotals gives UnsupportedOperationException calling getOrdinal".
`void`	`testXor()`
`void`	`testXorAssociativity()`
`void`	`testYtd()`

Methods inherited from class junit.framework.TestCase
countTestCases, createResult, getName, run, run, runBare, runTest, setName, setUp, toString

Methods inherited from class junit.framework.Assert
assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertFalse, assertFalse, assertNotNull, assertNotNull, assertNotSame, assertNotSame, assertNull, assertNull, assertSame, assertSame, assertTrue, assertTrue, fail, fail

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail
- FunctionTest
```
public FunctionTest()
```
  Creates a FunctionTest.
- FunctionTest
```
public FunctionTest(String s)
```
  Creates a FuncionTest with an explicit name.
  
  Parameters:
  s - Test name

Method Detail

testParallelPeriodMinValue
```
public void testParallelPeriodMinValue()
```
Tests that Integeer.MIN_VALUE(-2147483648) does not cause NPE.

testLagMinValue
```
public void testLagMinValue()
```
Tests that Integeer.MIN_VALUE(-2147483648) in Lag is handled correctly.

testParallelPeriodWithSlicer
```
public void testParallelPeriodWithSlicer()
```
Tests that ParallelPeriod with Aggregate function works

testParallelperiodOnLevelsString

public void testParallelperiodOnLevelsString()

testParallelperiodOnStrToMember

public void testParallelperiodOnStrToMember()

testNumericLiteral
```
public void testNumericLiteral()
```

testStringLiteral
```
public void testStringLiteral()
```

testDimensionHierarchy
```
public void testDimensionHierarchy()
```

testLevelDimension
```
public void testLevelDimension()
```

testMemberDimension
```
public void testMemberDimension()
```

testDimensionsNumeric
```
public void testDimensionsNumeric()
```

testDimensionsString
```
public void testDimensionsString()
```

testDimensionsDepends
```
public void testDimensionsDepends()
```

testTime
```
public void testTime()
```

testBasic9
```
public void testBasic9()
```

testFirstInLevel9
```
public void testFirstInLevel9()
```

testHierarchyAll
```
public void testHierarchyAll()
```

testNullMember
```
public void testNullMember()
```

testNullValue
```
public void testNullValue()
```
Tests use of NULL literal to generate a null cell value. Testcase is from bug 1440344.

testNullInMultiplication

public void testNullInMultiplication()

testNullInAddition
```
public void testNullInAddition()
```

testNullInSubtraction
```
public void testNullInSubtraction()
```

testMemberLevel
```
public void testMemberLevel()
```

testLevelsNumeric
```
public void testLevelsNumeric()
```

testLevelsTooSmall
```
public void testLevelsTooSmall()
```

testLevelsTooLarge
```
public void testLevelsTooLarge()
```

testHierarchyLevelsString

public void testHierarchyLevelsString()

testHierarchyLevelsStringFail

public void testHierarchyLevelsStringFail()

testLevelsString
```
public void testLevelsString()
```

testLevelsStringFail
```
public void testLevelsStringFail()
```

testIsEmptyQuery
```
public void testIsEmptyQuery()
```

testIsEmptyWithAggregate

public void testIsEmptyWithAggregate()

testIsEmpty
```
public void testIsEmpty()
```

testQueryWithoutValidMeasure

public void testQueryWithoutValidMeasure()

testValidMeasure
```
public void testValidMeasure()
```
Tests the ValidMeasure function.

_testValidMeasureNonEmpty

public void _testValidMeasureNonEmpty()

testValidMeasureTupleHasAnotherMember

public void testValidMeasureTupleHasAnotherMember()

testValidMeasureDepends
```
public void testValidMeasureDepends()
```

testValidMeasureNonVirtualCube

public void testValidMeasureNonVirtualCube()

testValidMeasureCalculatedMemberMeasure
```
public void testValidMeasureCalculatedMemberMeasure()
```
This is a test for MONDRIAN-2109
We can't allow calculated members in ValidMeasure so a proper message must be returned.

testAncestor
```
public void testAncestor()
```

testAncestorNumeric
```
public void testAncestorNumeric()
```

testAncestorHigher
```
public void testAncestorHigher()
```

testAncestorSameLevel
```
public void testAncestorSameLevel()
```

testAncestorWrongHierarchy

public void testAncestorWrongHierarchy()

testAncestorAllLevel
```
public void testAncestorAllLevel()
```

testAncestorWithHiddenParent

public void testAncestorWithHiddenParent()

testAncestorDepends
```
public void testAncestorDepends()
```

testAncestors
```
public void testAncestors()
```

testOrdinal
```
public void testOrdinal()
```

testClosingPeriodNoArgs
```
public void testClosingPeriodNoArgs()
```

testClosingPeriodLevel
```
public void testClosingPeriodLevel()
```

testClosingPeriodLevelNotInTimeFails

public void testClosingPeriodLevelNotInTimeFails()

testClosingPeriodMember
```
public void testClosingPeriodMember()
```

testClosingPeriodMemberLeaf

public void testClosingPeriodMemberLeaf()

testClosingPeriod
```
public void testClosingPeriod()
```

testClosingPeriodBelow
```
public void testClosingPeriodBelow()
```

testCousin1
```
public void testCousin1()
```

testCousin2
```
public void testCousin2()
```

testCousinOverrun
```
public void testCousinOverrun()
```

testCousinThreeDown
```
public void testCousinThreeDown()
```

testCousinSameLevel
```
public void testCousinSameLevel()
```

testCousinHigherLevel
```
public void testCousinHigherLevel()
```

testCousinWrongHierarchy

public void testCousinWrongHierarchy()

testParent
```
public void testParent()
```

testParentPC
```
public void testParentPC()
```

testMembers
```
public void testMembers()
```

testHierarchyMembers
```
public void testHierarchyMembers()
```

testAllMembers
```
public void testAllMembers()
```

testAddCalculatedMembers

public void testAddCalculatedMembers()

testStripCalculatedMembers

public void testStripCalculatedMembers()

testCurrentMember
```
public void testCurrentMember()
```

testCurrentMemberDepends

public void testCurrentMemberDepends()

testCurrentMemberFromSlicer

public void testCurrentMemberFromSlicer()

testCurrentMemberFromDefaultMember

public void testCurrentMemberFromDefaultMember()

testCurrentMemberMultiHierarchy

public void testCurrentMemberMultiHierarchy()

testDefaultMember
```
public void testDefaultMember()
```

testCurrentMemberFromAxis

public void testCurrentMemberFromAxis()

testCurrentMemberInCalcMember
```
public void testCurrentMemberInCalcMember()
```
When evaluating a calculated member, MSOLAP regards that calculated member as the current member of that dimension, so it cycles in this case. But I disagree; it is the previous current member, before the calculated member was expanded.

testNamedSetCurrentOrdinalWithOrder
```
public void testNamedSetCurrentOrdinalWithOrder()
```
Tests NamedSet.CurrentOrdinal combined with the Order function.

testNamedSetCurrentOrdinalWithGenerate
```
public void testNamedSetCurrentOrdinalWithGenerate()
```
Tests NamedSet.CurrentOrdinal combined with the Generate function.

testNamedSetCurrentOrdinalWithFilter

public void testNamedSetCurrentOrdinalWithFilter()

testNamedSetCurrentOrdinalWithCrossjoin

public void testNamedSetCurrentOrdinalWithCrossjoin()

testNamedSetCurrentOrdinalWithNonNamedSetFails

public void testNamedSetCurrentOrdinalWithNonNamedSetFails()

testDimensionDefaultMember

public void testDimensionDefaultMember()

testDrilldownLevel
```
public void testDrilldownLevel()
```

testDrilldownLevelTop
```
public void testDrilldownLevelTop()
```

testDrilldownMemberEmptyExpr

public void testDrilldownMemberEmptyExpr()

testDrilldownMember
```
public void testDrilldownMember()
```

testFirstChildFirstInLevel

public void testFirstChildFirstInLevel()

testFirstChildAll
```
public void testFirstChildAll()
```

testFirstChildOfChildless

public void testFirstChildOfChildless()

testFirstSiblingFirstInLevel

public void testFirstSiblingFirstInLevel()

testFirstSiblingLastInLevel

public void testFirstSiblingLastInLevel()

testFirstSiblingAll
```
public void testFirstSiblingAll()
```

testFirstSiblingRoot
```
public void testFirstSiblingRoot()
```

testFirstSiblingNull
```
public void testFirstSiblingNull()
```

testLag
```
public void testLag()
```

testLagFirstInLevel
```
public void testLagFirstInLevel()
```

testLagAll
```
public void testLagAll()
```

testLagRoot
```
public void testLagRoot()
```

testLagRootTooFar
```
public void testLagRootTooFar()
```

testLastChild
```
public void testLastChild()
```

testLastChildLastInLevel

public void testLastChildLastInLevel()

testLastChildAll
```
public void testLastChildAll()
```

testLastChildOfChildless

public void testLastChildOfChildless()

testLastSibling
```
public void testLastSibling()
```

testLastSiblingFirstInLevel

public void testLastSiblingFirstInLevel()

testLastSiblingAll
```
public void testLastSiblingAll()
```

testLastSiblingRoot
```
public void testLastSiblingRoot()
```

testLastSiblingNull
```
public void testLastSiblingNull()
```

testLead
```
public void testLead()
```

testLeadNegative
```
public void testLeadNegative()
```

testLeadLastInLevel
```
public void testLeadLastInLevel()
```

testLeadNull
```
public void testLeadNull()
```

testLeadZero
```
public void testLeadZero()
```

testBasic2
```
public void testBasic2()
```

testFirstInLevel2
```
public void testFirstInLevel2()
```

testAll2
```
public void testAll2()
```

testBasic5
```
public void testBasic5()
```

testFirstInLevel5
```
public void testFirstInLevel5()
```

testAll5
```
public void testAll5()
```

testBasic
```
public void testBasic()
```

testFirstInLevel
```
public void testFirstInLevel()
```

testAll
```
public void testAll()
```

testAggregateDepends
```
public void testAggregateDepends()
```

testAggregate
```
public void testAggregate()
```

testAggregate2
```
public void testAggregate2()
```

testAggregateWithIIF
```
public void testAggregateWithIIF()
```

testAggregate2AllMembers

public void testAggregate2AllMembers()

testAggregateToSimulateCompoundSlicer

public void testAggregateToSimulateCompoundSlicer()

testMultiselectCalculations
```
public void testMultiselectCalculations()
```
Tests behavior where CurrentMember occurs in calculated members and that member is a set.
Mosha discusses this behavior in the article Multiselect friendly MDX calculations.
Mondrian's behavior is consistent with MSAS 2K: it returns zeroes. SSAS 2005 returns an error, which can be fixed by reformulating the calculated members.

See Also:
FastBatchingCellReaderTest.testAggregateDistinctCount()

testAvg
```
public void testAvg()
```

testCorrelation
```
public void testCorrelation()
```

testCount
```
public void testCount()
```

testCountExcludeEmpty
```
public void testCountExcludeEmpty()
```

testCountExcludeEmptyNull
```
public void testCountExcludeEmptyNull()
```
Tests that the 'null' value is regarded as empty, even if the underlying cell has fact table rows.
For a fuller test case, see XmlaCognosTest.testCognosMDXSuiteConvertedAdventureWorksToFoodMart_015()

testCountExcludeEmptyOnCubeWithNoCountFacts
```
public void testCountExcludeEmptyOnCubeWithNoCountFacts()
```
Testcase for bug MONDRIAN-710, "Count with ExcludeEmpty throws an exception when the cube does not have a factCountMeasure".

testCountExcludeEmptyOnVirtualCubeWithNoCountFacts

public void testCountExcludeEmptyOnVirtualCubeWithNoCountFacts()

testCovariance
```
public void testCovariance()
```

testCovarianceN
```
public void testCovarianceN()
```

testIIfNumeric
```
public void testIIfNumeric()
```

testMax
```
public void testMax()
```

testMaxNegative
```
public void testMaxNegative()
```

testMedian
```
public void testMedian()
```

testMedian2
```
public void testMedian2()
```

testPercentile
```
public void testPercentile()
```

testPercentileBugMondrian1045
```
public void testPercentileBugMondrian1045()
```
Testcase for bug MONDRIAN-1045, "When I use the Percentile function it cracks when there's only 1 register".

testMin
```
public void testMin()
```

testMinTuple
```
public void testMinTuple()
```

testStdev
```
public void testStdev()
```

testStdevP
```
public void testStdevP()
```

testSumNoExp
```
public void testSumNoExp()
```

testValue
```
public void testValue()
```

testVar
```
public void testVar()
```

testVarP
```
public void testVarP()
```

testAs
```
public void testAs()
```
Tests the AS operator, that gives an expression an alias.

testAs2
```
public void testAs2()
```

testAscendants
```
public void testAscendants()
```

testAscendantsAll
```
public void testAscendantsAll()
```

testAscendantsNull
```
public void testAscendantsNull()
```

testBottomCount
```
public void testBottomCount()
```

testBottomPercent
```
public void testBottomPercent()
```

testBottomSum
```
public void testBottomSum()
```

testExceptEmpty
```
public void testExceptEmpty()
```

testExceptCrossjoin
```
public void testExceptCrossjoin()
```
Tests that Except() successfully removes crossjoined tuples from the axis results. Previously, this would fail by returning all tuples in the first argument to Except. bug 1439627

testExtract
```
public void testExtract()
```

testTopPercentCrossjoin
```
public void testTopPercentCrossjoin()
```
Tests that TopPercent() operates succesfully on a axis of crossjoined tuples. previously, this would fail with a ClassCastException in FunUtil.java. bug 1440306

testCrossjoinNested
```
public void testCrossjoinNested()
```

testCrossjoinSingletonTuples

public void testCrossjoinSingletonTuples()

testCrossjoinSingletonTuplesNested

public void testCrossjoinSingletonTuplesNested()

testCrossjoinAsterisk
```
public void testCrossjoinAsterisk()
```

testCrossjoinAsteriskTuple

public void testCrossjoinAsteriskTuple()

testCrossjoinAsteriskAssoc

public void testCrossjoinAsteriskAssoc()

testCrossjoinAsteriskInsideBraces

public void testCrossjoinAsteriskInsideBraces()

testCrossJoinAsteriskQuery

public void testCrossJoinAsteriskQuery()

testCrossjoinResolve
```
public void testCrossjoinResolve()
```
Testcase for bug 1889745, "StackOverflowError while resolving crossjoin". The problem occurs when a calculated member that references itself is referenced in a crossjoin.

testCrossjoinOrder
```
public void testCrossjoinOrder()
```
Test case for bug 1911832, "Exception converting immutable list to array in JDK 1.5".

testCrossjoinDupHierarchyFails

public void testCrossjoinDupHierarchyFails()

testCrossjoinDupDimensionOk
```
public void testCrossjoinDupDimensionOk()
```
Tests cases of different hierarchies in the same dimension. (Compare to testCrossjoinDupHierarchyFails()). Not an error.

testDescendantsM
```
public void testDescendantsM()
```

testDescendantsDepends
```
public void testDescendantsDepends()
```

testDescendantsML
```
public void testDescendantsML()
```

testDescendantsMLSelf
```
public void testDescendantsMLSelf()
```

testDescendantsMLLeaves
```
public void testDescendantsMLLeaves()
```

testDescendantsMLLeavesRagged

public void testDescendantsMLLeavesRagged()

testDescendantsMNLeaves
```
public void testDescendantsMNLeaves()
```

testDescendantsMLSelfBefore

public void testDescendantsMLSelfBefore()

testDescendantsMLSelfBeforeAfter

public void testDescendantsMLSelfBeforeAfter()

testDescendantsMLBefore
```
public void testDescendantsMLBefore()
```

testDescendantsMLBeforeAfter

public void testDescendantsMLBeforeAfter()

testDescendantsMLAfter
```
public void testDescendantsMLAfter()
```

testDescendantsMLAfterEnd

public void testDescendantsMLAfterEnd()

testDescendantsM0
```
public void testDescendantsM0()
```

testDescendantsM2
```
public void testDescendantsM2()
```

testDescendantsM2Self
```
public void testDescendantsM2Self()
```

testDescendantsM2Leaves
```
public void testDescendantsM2Leaves()
```

testDescendantsMFarLeaves

public void testDescendantsMFarLeaves()

testDescendantsMEmptyLeaves

public void testDescendantsMEmptyLeaves()

testDescendantsMEmptyLeavesFail

public void testDescendantsMEmptyLeavesFail()

testDescendantsMEmptyLeavesFail2

public void testDescendantsMEmptyLeavesFail2()

testDescendantsMFarSelf
```
public void testDescendantsMFarSelf()
```

testDescendantsMNY
```
public void testDescendantsMNY()
```

testDescendants2ndHier
```
public void testDescendants2ndHier()
```

testDescendantsParentChild

public void testDescendantsParentChild()

testDescendantsParentChildBefore

public void testDescendantsParentChildBefore()

testDescendantsParentChildLeaves

public void testDescendantsParentChildLeaves()

testDescendantsSBA
```
public void testDescendantsSBA()
```

testDescendantsSet
```
public void testDescendantsSet()
```

testDescendantsSetEmpty
```
public void testDescendantsSetEmpty()
```

testRange
```
public void testRange()
```

testNullRange
```
public void testNullRange()
```
tests that a null passed in returns an empty set in range function

testTwoNullRange
```
public void testTwoNullRange()
```
tests that an exception is thrown if both parameters in a range function are null.

testRangeLarge
```
public void testRangeLarge()
```
Large dimensions use a different member reader, therefore need to be tested separately.

testRangeStartEqualsEnd
```
public void testRangeStartEqualsEnd()
```

testRangeStartEqualsEndLarge

public void testRangeStartEqualsEndLarge()

testRangeEndBeforeStart
```
public void testRangeEndBeforeStart()
```

testRangeEndBeforeStartLarge

public void testRangeEndBeforeStartLarge()

testRangeBetweenDifferentLevelsIsError

public void testRangeBetweenDifferentLevelsIsError()

testRangeBoundedByAll
```
public void testRangeBoundedByAll()
```

testRangeBoundedByAllLarge

public void testRangeBoundedByAllLarge()

testRangeBoundedByNull
```
public void testRangeBoundedByNull()
```

testRangeBoundedByNullLarge

public void testRangeBoundedByNullLarge()

testSetContainingLevelFails

public void testSetContainingLevelFails()

testBug715177
```
public void testBug715177()
```

testBug714707
```
public void testBug714707()
```

testBug715177c
```
public void testBug715177c()
```

testFormatFixed
```
public void testFormatFixed()
```

testFormatVariable
```
public void testFormatVariable()
```

testFormatMember
```
public void testFormatMember()
```

testIIf
```
public void testIIf()
```

testIIfWithNullAndNumber

public void testIIfWithNullAndNumber()

testIIfWithStringAndNull

public void testIIfWithStringAndNull()

testIsEmptyWithNull
```
public void testIsEmptyWithNull()
```

testIIfMember
```
public void testIIfMember()
```

testIIfLevel
```
public void testIIfLevel()
```

testIIfHierarchy
```
public void testIIfHierarchy()
```

testIIfDimension
```
public void testIIfDimension()
```

testIIfSet
```
public void testIIfSet()
```

testDimensionCaption
```
public void testDimensionCaption()
```

testHierarchyCaption
```
public void testHierarchyCaption()
```

testLevelCaption
```
public void testLevelCaption()
```

testMemberCaption
```
public void testMemberCaption()
```

testDimensionName
```
public void testDimensionName()
```

testHierarchyName
```
public void testHierarchyName()
```

testLevelName
```
public void testLevelName()
```

testMemberName
```
public void testMemberName()
```

testDimensionUniqueName
```
public void testDimensionUniqueName()
```

testHierarchyUniqueName
```
public void testHierarchyUniqueName()
```

testLevelUniqueName
```
public void testLevelUniqueName()
```

testMemberUniqueName
```
public void testMemberUniqueName()
```

testMemberUniqueNameOfNull

public void testMemberUniqueNameOfNull()

testCoalesceEmptyDepends

public void testCoalesceEmptyDepends()

testCoalesceEmpty
```
public void testCoalesceEmpty()
```

testBrokenContextBug
```
public void testBrokenContextBug()
```

testSetItemInt
```
public void testSetItemInt()
```
Tests the function <Set>.Item(<Integer>).

testSetItemString
```
public void testSetItemString()
```
Tests the function <Set>.Item(<String> [,...]).

testTuple
```
public void testTuple()
```

testTupleArgTypes
```
public void testTupleArgTypes()
```
Tests whether the tuple operator can be applied to arguments of various types. See bug 1491699 "ClassCastException in mondrian.calc.impl.GenericCalc.evaluat".

testTupleItem
```
public void testTupleItem()
```

testTupleAppliedToUnknownHierarchy

public void testTupleAppliedToUnknownHierarchy()

testTupleDepends
```
public void testTupleDepends()
```

testItemNull
```
public void testItemNull()
```

testTupleNull
```
public void testTupleNull()
```

testLevelMemberExpressions

public void testLevelMemberExpressions()

testCaseTestMatch
```
public void testCaseTestMatch()
```

testCaseTestMatchElse
```
public void testCaseTestMatchElse()
```

testCaseTestMatchNoElse
```
public void testCaseTestMatchNoElse()
```

testCaseTestReturnsMemberBug1799391
```
public void testCaseTestReturnsMemberBug1799391()
```
Testcase for bug 1799391, "Case Test function throws class cast exception"

testCaseMatch
```
public void testCaseMatch()
```

testCaseMatchElse
```
public void testCaseMatchElse()
```

testCaseMatchNoElse
```
public void testCaseMatchNoElse()
```

testCaseTypeMismatch
```
public void testCaseTypeMismatch()
```

testCaseTuple
```
public void testCaseTuple()
```
Testcase for bug MONDRIAN-853, "When using CASE WHEN in a CalculatedMember values are not returned the way expected".

testPropertiesExpr
```
public void testPropertiesExpr()
```

testPropertiesOnDimension
```
public void testPropertiesOnDimension()
```
Test case for bug MONDRIAN-1227, "Properties function does not implicitly convert dimension to member; has documentation typos".

testPropertiesNonExistent
```
public void testPropertiesNonExistent()
```
Tests that non-existent property throws an error. *

testPropertiesFilter
```
public void testPropertiesFilter()
```

testPropertyInCalculatedMember

public void testPropertyInCalculatedMember()

testOpeningPeriod
```
public void testOpeningPeriod()
```

testOpeningPeriodNull
```
public void testOpeningPeriodNull()
```
This tests new NULL functionality exception throwing

testLastPeriods
```
public void testLastPeriods()
```

testParallelPeriod
```
public void testParallelPeriod()
```

_testParallelPeriodThrowsException

public void _testParallelPeriodThrowsException()

testParallelPeriodDepends

public void testParallelPeriodDepends()

testParallelPeriodLevelLag

public void testParallelPeriodLevelLag()

testParallelPeriodLevel
```
public void testParallelPeriodLevel()
```

testPlus
```
public void testPlus()
```

testMinus
```
public void testMinus()
```

testMinus_bug1234759
```
public void testMinus_bug1234759()
```

testMinusAssociativity
```
public void testMinusAssociativity()
```

testMultiply
```
public void testMultiply()
```

testMultiplyPrecedence
```
public void testMultiplyPrecedence()
```

testMultiplyBug774807
```
public void testMultiplyBug774807()
```
Bug 774807 caused expressions to be mistaken for the crossjoin operator.

testDivide
```
public void testDivide()
```

testDividePrecedence
```
public void testDividePrecedence()
```

testMod
```
public void testMod()
```

testUnaryMinus
```
public void testUnaryMinus()
```

testUnaryMinusMember
```
public void testUnaryMinusMember()
```

testUnaryMinusPrecedence

public void testUnaryMinusPrecedence()

testNegativeZero
```
public void testNegativeZero()
```

testNegativeZero1
```
public void testNegativeZero1()
```

testNegativeZeroSubtract

public void testNegativeZeroSubtract()

testNegativeZeroMultiply

public void testNegativeZeroMultiply()

testNegativeZeroDivide
```
public void testNegativeZeroDivide()
```

testString
```
public void testString()
```

testStringConcat
```
public void testStringConcat()
```

testStringConcat2
```
public void testStringConcat2()
```

testAnd
```
public void testAnd()
```

testAnd2
```
public void testAnd2()
```

testOr
```
public void testOr()
```

testOr2
```
public void testOr2()
```

testOrAssociativity1
```
public void testOrAssociativity1()
```

testOrAssociativity2
```
public void testOrAssociativity2()
```

testOrAssociativity3
```
public void testOrAssociativity3()
```

testXor
```
public void testXor()
```

testXorAssociativity
```
public void testXorAssociativity()
```

testNonEmptyCrossJoin
```
public void testNonEmptyCrossJoin()
```

testNot
```
public void testNot()
```

testNotNot
```
public void testNotNot()
```

testNotAssociativity
```
public void testNotAssociativity()
```

testIsNull
```
public void testIsNull()
```

testIsMember
```
public void testIsMember()
```

testIsString
```
public void testIsString()
```

testIsNumeric
```
public void testIsNumeric()
```

testIsTuple
```
public void testIsTuple()
```

testIsLevel
```
public void testIsLevel()
```

testIsHierarchy
```
public void testIsHierarchy()
```

testIsDimension
```
public void testIsDimension()
```

testStringEquals
```
public void testStringEquals()
```

testStringEqualsAssociativity

public void testStringEqualsAssociativity()

testStringEqualsEmpty
```
public void testStringEqualsEmpty()
```

testEq
```
public void testEq()
```

testStringNe
```
public void testStringNe()
```

testNe
```
public void testNe()
```

testNeInfinity
```
public void testNeInfinity()
```

testLt
```
public void testLt()
```

testLe
```
public void testLe()
```

testGt
```
public void testGt()
```

testGe
```
public void testGe()
```

testDistinctTwoMembers
```
public void testDistinctTwoMembers()
```

testDistinctThreeMembers

public void testDistinctThreeMembers()

testDistinctFourMembers
```
public void testDistinctFourMembers()
```

testDistinctTwoTuples
```
public void testDistinctTwoTuples()
```

testDistinctSomeTuples
```
public void testDistinctSomeTuples()
```

testFilterWithSlicer
```
public void testFilterWithSlicer()
```
Make sure that slicer is in force when expression is applied on axis, E.g. select filter([Customers].members, [Unit Sales] > 100) from sales where ([Time].[1998])

testFilterCompound
```
public void testFilterCompound()
```

testGenerateDepends
```
public void testGenerateDepends()
```

testGenerate
```
public void testGenerate()
```

testGenerateNonSet
```
public void testGenerateNonSet()
```

testGenerateAll
```
public void testGenerateAll()
```

testGenerateUnique
```
public void testGenerateUnique()
```

testGenerateUniqueTuple
```
public void testGenerateUniqueTuple()
```

testGenerateCrossJoin
```
public void testGenerateCrossJoin()
```

testGenerateString
```
public void testGenerateString()
```

testHead
```
public void testHead()
```

testHeadNegative
```
public void testHeadNegative()
```

testHeadDefault
```
public void testHeadDefault()
```

testHeadOvershoot
```
public void testHeadOvershoot()
```

testHeadEmpty
```
public void testHeadEmpty()
```

testHeadBug
```
public void testHeadBug()
```
Test case for bug 2488492, "Union between calc mem and head function throws exception"

testHierarchize
```
public void testHierarchize()
```

testHierarchizePost
```
public void testHierarchizePost()
```

testHierarchizePC
```
public void testHierarchizePC()
```

testHierarchizeCrossJoinPre

public void testHierarchizeCrossJoinPre()

testHierarchizeCrossJoinPost

public void testHierarchizeCrossJoinPost()

testHierarchizeOrdinal
```
public void testHierarchizeOrdinal()
```
Tests that the Hierarchize function works correctly when applied to a level whose ordering is determined by an 'ordinal' property. TODO: fix this test (bug 1220787) WG: Note that this is disabled right now due to its impact on other tests later on within the test suite, specifically XMLA tests that return a list of cubes. We could run this test after XMLA, or clear out the cache to solve this.

testIntersectAll
```
public void testIntersectAll()
```

testIntersect
```
public void testIntersect()
```

testIntersectTuples
```
public void testIntersectTuples()
```

testIntersectRightEmpty
```
public void testIntersectRightEmpty()
```

testIntersectLeftEmpty
```
public void testIntersectLeftEmpty()
```

testOrderDepends
```
public void testOrderDepends()
```

testOrderCalc
```
public void testOrderCalc()
```

testOrderWithMember
```
public void testOrderWithMember()
```
Verifies that the order function works with a defined member. See this forum post for additional information: http://forums.pentaho.com/showthread.php?p=179473#post179473

testOrderNonEmpty
```
public void testOrderNonEmpty()
```
test case for bug # 1797159, Potential MDX Order Non Empty Problem

testOrder
```
public void testOrder()
```

testOrderParentsMissing
```
public void testOrderParentsMissing()
```

testOrderCrossJoinBreak
```
public void testOrderCrossJoinBreak()
```

testOrderCrossJoin
```
public void testOrderCrossJoin()
```

testOrderHierarchicalDesc

public void testOrderHierarchicalDesc()

testOrderCrossJoinDesc
```
public void testOrderCrossJoinDesc()
```

testOrderBug656802
```
public void testOrderBug656802()
```

testOrderBug712702_Simplified

public void testOrderBug712702_Simplified()

testOrderBug712702_Original

public void testOrderBug712702_Original()

testOrderEmpty
```
public void testOrderEmpty()
```

testOrderOne
```
public void testOrderOne()
```

testOrderKeyEmpty
```
public void testOrderKeyEmpty()
```

testOrderKeyOne
```
public void testOrderKeyOne()
```

testOrderDesc
```
public void testOrderDesc()
```

testOrderMemberMemberValueExpNew

public void testOrderMemberMemberValueExpNew()

testOrderMemberMemberValueExpNew1

public void testOrderMemberMemberValueExpNew1()

testOrderMemberDefaultFlag1

public void testOrderMemberDefaultFlag1()

testOrderMemberDefaultFlag2

public void testOrderMemberDefaultFlag2()

testOrderMemberMemberValueExpHierarchy

public void testOrderMemberMemberValueExpHierarchy()

testOrderMemberMultiKeysMemberValueExp1

public void testOrderMemberMultiKeysMemberValueExp1()

testOrderMemberMultiKeysMemberValueExp2

public void testOrderMemberMultiKeysMemberValueExp2()

testOrderMemberMultiKeysMemberValueExpDepends

public void testOrderMemberMultiKeysMemberValueExpDepends()

testOrderTupleSingleKeysNew

public void testOrderTupleSingleKeysNew()

testOrderTupleSingleKeysNew1

public void testOrderTupleSingleKeysNew1()

testOrderTupleMultiKeys1

public void testOrderTupleMultiKeys1()

testOrderTupleMultiKeys2

public void testOrderTupleMultiKeys2()

testOrderTupleMultiKeys3

public void testOrderTupleMultiKeys3()

testOrderTupleMultiKeyswithVCube

public void testOrderTupleMultiKeyswithVCube()

testOrderConstant1
```
public void testOrderConstant1()
```

testOrderDiffrentDim
```
public void testOrderDiffrentDim()
```

testUnorder
```
public void testUnorder()
```

testSiblingsA
```
public void testSiblingsA()
```

testSiblingsB
```
public void testSiblingsB()
```

testSiblingsC
```
public void testSiblingsC()
```

testSiblingsD
```
public void testSiblingsD()
```

testSubset
```
public void testSubset()
```

testSubsetNegativeCount
```
public void testSubsetNegativeCount()
```

testSubsetNegativeStart
```
public void testSubsetNegativeStart()
```

testSubsetDefault
```
public void testSubsetDefault()
```

testSubsetOvershoot
```
public void testSubsetOvershoot()
```

testSubsetEmpty
```
public void testSubsetEmpty()
```

testTail
```
public void testTail()
```

testTailNegative
```
public void testTailNegative()
```

testTailDefault
```
public void testTailDefault()
```

testTailOvershoot
```
public void testTailOvershoot()
```

testTailEmpty
```
public void testTailEmpty()
```

testToggleDrillState
```
public void testToggleDrillState()
```

testToggleDrillState2
```
public void testToggleDrillState2()
```

testToggleDrillState3
```
public void testToggleDrillState3()
```

testToggleDrillStateTuple

public void testToggleDrillStateTuple()

testToggleDrillStateRecursive

public void testToggleDrillStateRecursive()

testTopCount
```
public void testTopCount()
```

testTopCountTuple
```
public void testTopCountTuple()
```

testTopCountEmpty
```
public void testTopCountEmpty()
```

testTopCountDepends
```
public void testTopCountDepends()
```

testTopCountHuge
```
public void testTopCountHuge()
```
Tests TopCount applied to a large result set.
Before optimizing (see FunUtil.partialSort), on a 2-core 32-bit 2.4GHz machine, the 1st query took 14.5 secs, the 2nd query took 5.0 secs. After optimizing, who knows?

testTopPercent
```
public void testTopPercent()
```

testTopSum
```
public void testTopSum()
```

testTopSumEmpty
```
public void testTopSumEmpty()
```

testUnionAll
```
public void testUnionAll()
```

testUnionAllTuple
```
public void testUnionAllTuple()
```

testUnion
```
public void testUnion()
```

testUnionEmptyBoth
```
public void testUnionEmptyBoth()
```

testUnionEmptyRight
```
public void testUnionEmptyRight()
```

testUnionTuple
```
public void testUnionTuple()
```

testUnionTupleDistinct
```
public void testUnionTupleDistinct()
```

testUnionQuery
```
public void testUnionQuery()
```

testItemMember
```
public void testItemMember()
```

testItemTuple
```
public void testItemTuple()
```

testStrToMember
```
public void testStrToMember()
```

testStrToMemberUniqueName

public void testStrToMemberUniqueName()

testStrToMemberFullyQualifiedName

public void testStrToMemberFullyQualifiedName()

testStrToMemberNull
```
public void testStrToMemberNull()
```

testStrToMemberIgnoreInvalidMembers
```
public void testStrToMemberIgnoreInvalidMembers()
```
Testcase for bug MONDRIAN-560, "StrToMember function doesn't use IgnoreInvalidMembers option".

testStrToTuple
```
public void testStrToTuple()
```

testStrToTupleIgnoreInvalidMembers

public void testStrToTupleIgnoreInvalidMembers()

testStrToTupleDuHierarchiesFails

public void testStrToTupleDuHierarchiesFails()

testStrToTupleDupHierInSameDimensions

public void testStrToTupleDupHierInSameDimensions()

testStrToTupleDepends
```
public void testStrToTupleDepends()
```

testStrToSet
```
public void testStrToSet()
```

testStrToSetDupDimensionsFails

public void testStrToSetDupDimensionsFails()

testStrToSetIgnoreInvalidMembers

public void testStrToSetIgnoreInvalidMembers()

testYtd
```
public void testYtd()
```

testGeneratePlusXtd
```
public void testGeneratePlusXtd()
```
Testcase for bug MONDRIAN-458, "error deducing type of Ytd/Qtd/Mtd functions within Generate".

testQtd
```
public void testQtd()
```

testMtd
```
public void testMtd()
```

testPeriodsToDate
```
public void testPeriodsToDate()
```

testSetToStr
```
public void testSetToStr()
```

testTupleToStr
```
public void testTupleToStr()
```

assertExprReturns
```
public void assertExprReturns(String expr,
                     String expected)
```
Executes a scalar expression, and asserts that the result is as expected. For example, assertExprReturns("1 + 2", "3") should succeed.

Overrides:

assertExprReturns in class FoodMartTestCase

assertExprReturns
```
public void assertExprReturns(String expr,
                     double expected,
                     double delta)
```
Executes a scalar expression, and asserts that the result is within delta of the expected result.

Parameters:
expr - MDX scalar expression
expected - Expected value
delta - Maximum allowed deviation from expected value

assertExprCompilesTo

public void assertExprCompilesTo(String expr,
                        String expectedCalc)

Compiles a scalar expression, and asserts that the program looks as expected.

assertAxisCompilesTo

public void assertAxisCompilesTo(String expr,
                        String expectedCalc)

Compiles a set expression, and asserts that the program looks as expected.

testRank
```
public void testRank()
```
Tests the Rank(member, set) MDX function.

testRankWithExpr
```
public void testRankWithExpr()
```

testRankMembersWithTiedExpr

public void testRankMembersWithTiedExpr()

testRankTuplesWithTiedExpr

public void testRankTuplesWithTiedExpr()

testRankWithExpr2
```
public void testRankWithExpr2()
```

testRankWithNulls
```
public void testRankWithNulls()
```
Tests the 3-arg version of the RANK function with a value which returns null within a set of nulls.

testRankHuge
```
public void testRankHuge()
```
Tests a RANK function which is so large that we need to use caching in order to execute it efficiently.

_testRank3Huge
```
public void _testRank3Huge()
```
As testRankHuge(), but for the 3-argument form of the RANK function.
Disabled by jhyde, 2006/2/14. Bug 1431316 logged.

testLinRegPointQuarter
```
public void testLinRegPointQuarter()
```

_testLinRegAll
```
public void _testLinRegAll()
```
Tests all of the linear regression functions, as suggested by a Microsoft knowledge base article.

testLinRegPointMonth
```
public void testLinRegPointMonth()
```

testLinRegIntercept
```
public void testLinRegIntercept()
```

testLinRegSlope
```
public void testLinRegSlope()
```

testLinRegPoint
```
public void testLinRegPoint()
```

_testLinRegR2
```
public void _testLinRegR2()
```

_testLinRegVariance
```
public void _testLinRegVariance()
```

testVisualTotalsBasic
```
public void testVisualTotalsBasic()
```

testVisualTotalsConsecutively

public void testVisualTotalsConsecutively()

testVisualTotalsNoPattern

public void testVisualTotalsNoPattern()

testVisualTotalsWithFilter

public void testVisualTotalsWithFilter()

testVisualTotalsNested
```
public void testVisualTotalsNested()
```

testVisualTotalsFilterInside

public void testVisualTotalsFilterInside()

testVisualTotalsOutOfOrder

public void testVisualTotalsOutOfOrder()

testVisualTotalsGrandparentsAndOutOfOrder

public void testVisualTotalsGrandparentsAndOutOfOrder()

testVisualTotalsCrossjoin

public void testVisualTotalsCrossjoin()

testVisualTotalsAll
```
public void testVisualTotalsAll()
```
Test case for bug MONDRIAN-615, "VisualTotals doesn't work for the all member".

testVisualTotalsWithNamedSetAndPivot
```
public void testVisualTotalsWithNamedSetAndPivot()
```
Test case involving a named set and query pivoted. Suggested in MONDRIAN-615, "VisualTotals doesn't work for the all member".

testVisualTotalsIntersect
```
public void testVisualTotalsIntersect()
```
Tests that members generated by VisualTotals have correct identity.
Testcase for bug MONDRIAN-295, "Query generated by Excel 2007 gives incorrect results".

testVisualTotalsWithNamedSetAndPivotSameAxis
```
public void testVisualTotalsWithNamedSetAndPivotSameAxis()
```
Testcase for bug MONDRIAN-668, "Intersect should return any VisualTotals members in right-hand set".

testVisualTotalsDistinctCountMeasure
```
public void testVisualTotalsDistinctCountMeasure()
```
Testcase for bug MONDRIAN-682, "VisualTotals + Distinct-count measure gives wrong results".

testVisualTotalsClassCast
```
public void testVisualTotalsClassCast()
```
Testcase for bug MONDRIAN-761, "VisualTotalMember cannot be cast to RolapCubeMember".

testVisualTotalsWithNamedSetOfTuples
```
public void testVisualTotalsWithNamedSetOfTuples()
```
Testcase for bug MONDRIAN-678, "VisualTotals gives UnsupportedOperationException calling getOrdinal". Key difference from previous test is that there are multiple hierarchies in Named set.

testVisualTotalsLevel
```
public void testVisualTotalsLevel()
```

testVisualTotalsMemberInCalculation
```
public void testVisualTotalsMemberInCalculation()
```
Testcase for bug MONDRIAN-749, "Cannot use visual totals members in calculations".
The bug is not currently fixed, so it is a negative test case. Row #2 cell #1 contains an exception, but should be "**Subtotal - Bread : Product Subcategory".

testCalculatedChild
```
public void testCalculatedChild()
```

testCalculatedChildUsingItem

public void testCalculatedChildUsingItem()

testCalculatedChildOnMemberWithNoChildren

public void testCalculatedChildOnMemberWithNoChildren()

testCalculatedChildOnNullMember

public void testCalculatedChildOnNullMember()

testCast
```
public void testCast()
```

testCastBug524
```
public void testCastBug524()
```
Testcase for bug MONDRIAN-524, "VB functions: expected primitive type, got java.lang.Object".

testDumpFunctions
```
public void testDumpFunctions()
                       throws IOException
```
Tests FunTable.getFunInfoList(), but more importantly, generates an HTML table of all implemented functions into a file called "functions.html". You can manually include that table in the MDX specification.

Throws:

IOException

testComplexOrExpr
```
public void testComplexOrExpr()
```

testLeftFunctionWithValidArguments

public void testLeftFunctionWithValidArguments()

testLeftFunctionWithLengthValueZero

public void testLeftFunctionWithLengthValueZero()

testLeftFunctionWithLengthValueEqualToStringLength

public void testLeftFunctionWithLengthValueEqualToStringLength()

testLeftFunctionWithLengthMoreThanStringLength

public void testLeftFunctionWithLengthMoreThanStringLength()

testLeftFunctionWithZeroLengthString

public void testLeftFunctionWithZeroLengthString()

testLeftFunctionWithNegativeLength

public void testLeftFunctionWithNegativeLength()

testMidFunctionWithValidArguments

public void testMidFunctionWithValidArguments()

testMidFunctionWithZeroLengthStringArgument

public void testMidFunctionWithZeroLengthStringArgument()

testMidFunctionWithLengthArgumentLargerThanStringLength

public void testMidFunctionWithLengthArgumentLargerThanStringLength()

testMidFunctionWithStartIndexGreaterThanStringLength

public void testMidFunctionWithStartIndexGreaterThanStringLength()

testMidFunctionWithStartIndexZeroFails

public void testMidFunctionWithStartIndexZeroFails()

testMidFunctionWithStartIndexOne

public void testMidFunctionWithStartIndexOne()

testMidFunctionWithNegativeStartIndex

public void testMidFunctionWithNegativeStartIndex()

testMidFunctionWithNegativeLength

public void testMidFunctionWithNegativeLength()

testMidFunctionWithoutLength

public void testMidFunctionWithoutLength()

testLenFunctionWithNonEmptyString

public void testLenFunctionWithNonEmptyString()

testLenFunctionWithAnEmptyString

public void testLenFunctionWithAnEmptyString()

testLenFunctionWithNullString

public void testLenFunctionWithNullString()

testUCaseWithNonEmptyString

public void testUCaseWithNonEmptyString()

testUCaseWithEmptyString

public void testUCaseWithEmptyString()

testInStrFunctionWithValidArguments

public void testInStrFunctionWithValidArguments()

testIifFWithBooleanBooleanAndNumericParameterForReturningTruePart

public void testIifFWithBooleanBooleanAndNumericParameterForReturningTruePart()

testIifWithBooleanBooleanAndNumericParameterForReturningFalsePart

public void testIifWithBooleanBooleanAndNumericParameterForReturningFalsePart()

testIIFWithBooleanBooleanAndNumericParameterForReturningZero

public void testIIFWithBooleanBooleanAndNumericParameterForReturningZero()

testInStrFunctionWithEmptyString1

public void testInStrFunctionWithEmptyString1()

testInStrFunctionWithEmptyString2

public void testInStrFunctionWithEmptyString2()

testGetCaptionUsingMemberDotCaption

public void testGetCaptionUsingMemberDotCaption()

testCache
```
public void testCache()
```

testVbaBasic
```
public void testVbaBasic()
```

testVbaOverloading
```
public void testVbaOverloading()
```

testVbaExceptions
```
public void testVbaExceptions()
```

testVbaDateTime
```
public void testVbaDateTime()
```

testExcelPi
```
public void testExcelPi()
```

testExcelPower
```
public void testExcelPower()
```

testBug1881739
```
public void testBug1881739()
```

testCubeTimeDimensionFails
```
public void testCubeTimeDimensionFails()
```
Testcase for bug MONDRIAN-296, "Cube getTimeDimension use when Cube has no Time dimension".

testFilterEmpty
```
public void testFilterEmpty()
```

testFilterCalcSlicer
```
public void testFilterCalcSlicer()
```

testExistsMembersAll
```
public void testExistsMembersAll()
```

testExistsMembersLevel2
```
public void testExistsMembersLevel2()
```

testExistsWithImplicitAllMember

public void testExistsWithImplicitAllMember()

testExistsWithMultipleHierarchies

public void testExistsWithMultipleHierarchies()

testExistsWithDefaultNonAllMember

public void testExistsWithDefaultNonAllMember()

testExistsMembers2Hierarchies

public void testExistsMembers2Hierarchies()

testExistsTuplesAll
```
public void testExistsTuplesAll()
```

testExistsTuplesLevel2
```
public void testExistsTuplesLevel2()
```

testExistsTuplesLevel23
```
public void testExistsTuplesLevel23()
```

testExistsTuples2Dim
```
public void testExistsTuples2Dim()
```

testExistsTuplesDiffDim
```
public void testExistsTuplesDiffDim()
```

testComplexQuery
```
public void testComplexQuery()
```
Executes a query that has a complex parse tree. Goal is to find algorithmic complexity bugs in the validator which would make the query run extremely slowly.

testDateParameter
```
public void testDateParameter()
                       throws Exception
```
Testcase for bug MONDRIAN-1050, "MDX Order function fails when using DateTime expression for ordering".

Throws:

Exception

testHierarchizeExcept
```
public void testHierarchizeExcept()
                           throws Exception
```
Testcase for bug MONDRIAN-1043, "Hierarchize with Except sort set members differently than in Mondrian 3.2.1".
This test makes sure that Hierarchize and Except can be used within each other and that the sort order is maintained.

Throws:

Exception

testTopPercentWithAlias
```
public void testTopPercentWithAlias()
```
This is a test for MONDRIAN-2157

The results should be equivalent either we use aliases or not

Class FunctionTest

Field Summary

Fields inherited from class mondrian.test.FoodMartTestCase

Constructor Summary

Method Summary

Methods inherited from class mondrian.test.FoodMartTestCase

Methods inherited from class junit.framework.TestCase

Methods inherited from class junit.framework.Assert

Methods inherited from class java.lang.Object

Constructor Detail

FunctionTest

FunctionTest

Method Detail

testParallelPeriodMinValue

testLagMinValue

testParallelPeriodWithSlicer

testParallelperiodOnLevelsString

testParallelperiodOnStrToMember

testNumericLiteral

testStringLiteral

testDimensionHierarchy

testLevelDimension

testMemberDimension

testDimensionsNumeric

testDimensionsString

testDimensionsDepends

testTime

testBasic9

testFirstInLevel9

testHierarchyAll

testNullMember

testNullValue

testNullInMultiplication

testNullInAddition

testNullInSubtraction

testMemberLevel

testLevelsNumeric

testLevelsTooSmall

testLevelsTooLarge

testHierarchyLevelsString

testHierarchyLevelsStringFail

testLevelsString

testLevelsStringFail

testIsEmptyQuery

testIsEmptyWithAggregate

testIsEmpty

testQueryWithoutValidMeasure

testValidMeasure

_testValidMeasureNonEmpty

testValidMeasureTupleHasAnotherMember

testValidMeasureDepends

testValidMeasureNonVirtualCube

testValidMeasureCalculatedMemberMeasure

testAncestor

testAncestorNumeric

testAncestorHigher

testAncestorSameLevel

testAncestorWrongHierarchy

testAncestorAllLevel

testAncestorWithHiddenParent

testAncestorDepends

testAncestors

testOrdinal

testClosingPeriodNoArgs

testClosingPeriodLevel

testClosingPeriodLevelNotInTimeFails

testClosingPeriodMember

testClosingPeriodMemberLeaf

testClosingPeriod

testClosingPeriodBelow

testCousin1

testCousin2

testCousinOverrun

testCousinThreeDown

testCousinSameLevel

testCousinHigherLevel

testCousinWrongHierarchy

testParent

testParentPC

testMembers