public void GetOutputStructure_WrongComponentTwoDatasetsJoinExpr_DurationScalarStructure(bool isMemership, TestExprType type) { foreach (string name in DatasetClauseOperator.ClauseNames.Where(name => !name.In("Pivot", "Unpivot", "Subspace"))) { IExpression joinExpr = ModelResolvers.JoinExprResolver(TestExprFactory.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol)); IExpression ds1Expr = TestExprFactory.GetExpression("get", ExpressionFactoryNameTarget.OperatorSymbol); IExpression ds2Expr = TestExprFactory.GetExpression("get", ExpressionFactoryNameTarget.OperatorSymbol); IExpression clauseExpr = TestExprFactory.GetExpression(name, ExpressionFactoryNameTarget.ResultName); IExpression periodIndicatorExpr = TestExprFactory.GetExpression("period_indicator", ExpressionFactoryNameTarget.OperatorSymbol); IExpression paramExpr = TestExprFactory.GetExpression(type); if (isMemership) { paramExpr.OperatorDefinition = ModelResolvers.OperatorResolver("#"); } joinExpr.AddOperand("ds", ModelResolvers.ExprResolver()); joinExpr.Operands["ds"].AddOperand("ds_1", ds1Expr); joinExpr.Operands["ds"].AddOperand("ds_2", ds2Expr); joinExpr.AddOperand(name, clauseExpr); clauseExpr.AddOperand("ds_1", periodIndicatorExpr); periodIndicatorExpr.AddOperand("ds_1", paramExpr); ds1Expr.Structure = ModelResolvers.DsResolver(); ds1Expr.Structure.Identifiers.Add(new StructureComponent(BasicDataType.Integer, "Id1")); ds1Expr.Structure.Identifiers.Add(new StructureComponent((BasicDataType)type, "Id2")); ds1Expr.Structure.Measures.Add(new StructureComponent(BasicDataType.String, "Me1")); ds2Expr.Structure = ds1Expr.Structure.GetCopy(); Assert.ThrowsAny <VtlOperatorError>(() => { periodIndicatorExpr.OperatorDefinition.GetOutputStructure(periodIndicatorExpr); }); } }
public void Build_Expr_Expr(params string[] opSymbols) { DsBranch dsBranch = new DsBranch(this._exprFac, this._exprTextGenerator); IExpression expr = ModelResolvers.ExprResolver(); IExpression expected = ModelResolvers.ExprResolver(); for (int i = 0; i < opSymbols.Length; i++) { IExpression subExpr = this._exprFac.GetExpression(opSymbols[i], ExpressionFactoryNameTarget.OperatorSymbol); // local expFactory expected subExpr.Structure = ModelResolvers.DsResolver(); subExpr.ExpressionText = opSymbols[i]; expr.AddOperand($"ds_{i}", subExpr); if (opSymbols[i].In("get", "ref", "#", "join")) { expected.AddOperand($"ds_{i}", subExpr); } } IExpression result = dsBranch.Build(expr); Assert.Equal(expected.OperandsCollection.Count, result.OperandsCollection.Count); foreach (string opSymbol in opSymbols.Where(opS => opS.In("get", "ref", "#", "join"))) { Assert.True(result.OperandsCollection.Where(op => op.OperatorSymbol == opSymbol).Count() == 1); } }
public void Constructor_JoinExpr_JoinExpr() { IExpression expr = TestExprFactory.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol); IExpression refExpr = ModelResolvers.ExprResolver(); ITransformationSchema schema = ModelResolvers.SchemaResolver(); refExpr.AddOperand("ds", expr); expr.ContainingSchema = schema; expr.ReferenceExpression = refExpr; IJoinExpression joinExpr2 = ModelResolvers.JoinExprResolver(expr); joinExpr2.BasicStructure = ModelResolvers.DsResolver(); JoinExpression joinExpr = new JoinExpression(joinExpr2); Assert.Equal(expr.ParentExpression, joinExpr.ParentExpression); Assert.Equal(expr.ContainingSchema, joinExpr.ContainingSchema); Assert.Equal(expr.ExpressionText, joinExpr.ExpressionText); Assert.Equal(expr.LineNumber, joinExpr.LineNumber); Assert.Equal(expr.OperandsCollection, joinExpr.OperandsCollection); Assert.Equal(expr.OperatorDefinition, joinExpr.OperatorDefinition); Assert.Equal(expr.ParamSignature, joinExpr.ParamSignature); Assert.Equal(expr.ReferenceExpression, joinExpr.ReferenceExpression); Assert.Equal(expr.ResultName, joinExpr.ResultName); Assert.Equal(expr.Structure, joinExpr.Structure); Assert.Equal(joinExpr2.BasicStructure, joinExpr.BasicStructure); }
public void Build_NotAggrAnalyticOperatorExpr_Expr(string opSymbol) { ApplyBranch applyBranch = new ApplyBranch(ModelResolvers.ExprResolver, this._exprTextGenerator); Mock <IOperatorDefinition> opDefMock = new Mock <IOperatorDefinition>(); opDefMock.SetupGet(opDef => opDef.Symbol).Returns(opSymbol); opDefMock.Setup(opDef => opDef.GetOutputStructure(It.IsAny <IExpression>())) .Returns((IExpression expr) => { return(ModelResolvers.DsResolver()); }); IExpression expr = TestExprFactory.GetExpression(opSymbol, ExpressionFactoryNameTarget.OperatorSymbol); expr.OperatorDefinition = opDefMock.Object; expr.AddOperand("ds", ModelResolvers.ExprResolver()); expr.AddOperand("group", ModelResolvers.ExprResolver()); expr.AddOperand("having", ModelResolvers.ExprResolver()); expr.AddOperand("over", ModelResolvers.ExprResolver()); IExpression result = applyBranch.Build(expr); Assert.NotNull(result.Structure); Assert.Equal("Generated text", result.ExpressionText); Assert.Equal("Apply", result.ResultName); Assert.Equal("apply", result.ParamSignature); Assert.Equal(expr.OperatorSymbol, result.OperatorSymbol); Assert.Equal(expr.OperandsCollection.Count, result.OperandsCollection.Count); for (int i = 0; i < expr.OperandsCollection.Count; i++) { Assert.Equal(expr.OperandsCollection.ToArray()[i].ParamSignature, result.OperandsCollection.ToArray()[i].ParamSignature); } }
public void GetOutputStructure_CorrectDatasetCollectionExpr_BoolScalarStructure() { foreach (string opSymbol in this._operators) { IExpression collectionExpr = ModelResolvers.ExprResolver(); collectionExpr.Structure = ModelResolvers.DsResolver(); collectionExpr.OperatorDefinition = ModelResolvers.OperatorResolver("collection"); collectionExpr.Structure.Measures.Add(new StructureComponent(BasicDataType.Integer)); collectionExpr.Structure.Measures.Add(new StructureComponent(BasicDataType.Number)); collectionExpr.Structure.Measures.Add(new StructureComponent(BasicDataType.None)); IExpression inExpr = ModelResolvers.ExprResolver(); inExpr.AddOperand("ds_1", TestExprFactory.GetExpression(TestExprType.NumbersDataset)); inExpr.AddOperand("ds_2", collectionExpr); inExpr.Operands["ds_1"].Structure.Measures.RemoveAt(1); inExpr.OperatorDefinition = ModelResolvers.OperatorResolver(opSymbol); IExpression expected = TestExprFactory.GetExpression(TestExprType.BoolsDataset); expected.Structure.Measures.RemoveAt(1); IDataStructure dataStructure = inExpr.OperatorDefinition.GetOutputStructure(inExpr); Assert.True(expected.Structure.EqualsObj(dataStructure)); } }
public void IsPartOfBranch_Exprs_CorrectResult() { IExpression branchExpr1 = ModelResolvers.ExprResolver(); IExpression branchExpr2 = ModelResolvers.ExprResolver(); IExpression expr1 = ModelResolvers.ExprResolver(); IExpression expr2 = ModelResolvers.ExprResolver(); IExpression expr3 = ModelResolvers.ExprResolver(); JoinExpression joinExpr = new JoinExpression(TestExprFactory.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol)); joinExpr.AddOperand("branch_1", branchExpr1); joinExpr.AddOperand("branch_2", branchExpr2); branchExpr1.AddOperand("ds_1", expr1); branchExpr2.AddOperand("ds_1", expr2); Assert.True(joinExpr.IsPartOfBranch("branch_1", branchExpr1)); Assert.True(joinExpr.IsPartOfBranch("branch_1", expr1)); Assert.True(joinExpr.IsPartOfBranch("branch_2", branchExpr2)); Assert.True(joinExpr.IsPartOfBranch("branch_2", expr2)); Assert.False(joinExpr.IsPartOfBranch("branch_2", branchExpr1)); Assert.False(joinExpr.IsPartOfBranch("branch_2", expr1)); Assert.False(joinExpr.IsPartOfBranch("branch_1", branchExpr2)); Assert.False(joinExpr.IsPartOfBranch("branch_1", expr2)); Assert.False(joinExpr.IsPartOfBranch("branch_1", expr3)); Assert.False(joinExpr.IsPartOfBranch("branch_2", expr3)); }
public void Constructor_HasCorrectParentExpression() { IExpression parentExpr = ModelResolvers.ExprResolver(); Expression expr = new Expression(parentExpr); Assert.Equal(parentExpr, expr.ParentExpression); }
public void GetOutputStructure_CorrectNoParamOneDatasetJoinExpr_DurationScalarStructure() { foreach (string name in DatasetClauseOperator.ClauseNames.Where(name => !name.In("Pivot", "Unpivot", "Subspace"))) { IExpression joinExpr = ModelResolvers.JoinExprResolver(TestExprFactory.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol)); IExpression datasetExpr = TestExprFactory.GetExpression("get", ExpressionFactoryNameTarget.OperatorSymbol); IExpression clauseExpr = TestExprFactory.GetExpression(name, ExpressionFactoryNameTarget.ResultName); IExpression periodIndicatorExpr = TestExprFactory.GetExpression("period_indicator", ExpressionFactoryNameTarget.OperatorSymbol); joinExpr.AddOperand("ds", ModelResolvers.ExprResolver()); joinExpr.Operands["ds"].AddOperand("ds_1", datasetExpr); joinExpr.AddOperand(name, clauseExpr); clauseExpr.AddOperand("ds_1", periodIndicatorExpr); datasetExpr.Structure = ModelResolvers.DsResolver(); datasetExpr.Structure.Identifiers.Add(new StructureComponent(BasicDataType.Integer, "Id1")); datasetExpr.Structure.Identifiers.Add(new StructureComponent(BasicDataType.TimePeriod, "Id2")); datasetExpr.Structure.Measures.Add(new StructureComponent(BasicDataType.String, "Me1")); IDataStructure expectedStructure = ModelResolvers.DsResolver("duration_var", ComponentType.Measure, BasicDataType.Duration); IDataStructure dataStructure = periodIndicatorExpr.OperatorDefinition.GetOutputStructure(periodIndicatorExpr); Assert.True(expectedStructure.EqualsObj(dataStructure)); } }
public void Build_AggrAnalyticOperatorExpr_Expr() { List <string> opSymbols = new List <string>(AggrFunctionOperator.Symbols); opSymbols.AddRange(AnalyticFunctionOperator.Symbols); foreach (string opSymbol in opSymbols) { ApplyBranch applyBranch = new ApplyBranch(ModelResolvers.ExprResolver, this._exprTextGenerator); Mock <IOperatorDefinition> opDefMock = new Mock <IOperatorDefinition>(); opDefMock.SetupGet(opDef => opDef.Symbol).Returns(opSymbol); opDefMock.Setup(opDef => opDef.GetOutputStructure(It.IsAny <IExpression>())) .Returns((IExpression expr) => { return(ModelResolvers.DsResolver()); }); IExpression expr = TestExprFactory.GetExpression(opSymbol, ExpressionFactoryNameTarget.OperatorSymbol); expr.OperatorDefinition = opDefMock.Object; expr.AddOperand("ds", ModelResolvers.ExprResolver()); expr.AddOperand("group", ModelResolvers.ExprResolver()); expr.AddOperand("having", ModelResolvers.ExprResolver()); expr.AddOperand("over", ModelResolvers.ExprResolver()); IExpression result = applyBranch.Build(expr); Assert.NotNull(result.Structure); Assert.Equal("Generated text", result.ExpressionText); Assert.Equal("Apply", result.ResultName); Assert.Equal("apply", result.ParamSignature); Assert.Equal(expr.OperatorSymbol, result.OperatorSymbol); Assert.Equal(1, result.OperandsCollection.Count); Assert.True(result.Operands.ContainsKey("ds")); } }
public void GetOutputStructure_GroupNScalarsExpr_DataStructure() { IJoinExpression joinExpr = ModelResolvers.JoinExprResolver(this._exprFac.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol)); for (int i = 3; i <= 5; i++) // very expensive { TestExprType[][] combinations = Enum.GetValues(typeof(TestExprType)).Cast <TestExprType>().Where(type => (int)type <= 8).GetCombinations(i); foreach (TestExprType[] combination in combinations) { IExpression compCreateExpr = this._exprFac.GetExpression("group", ExpressionFactoryNameTarget.OperatorSymbol); joinExpr.AddOperand("ds_1", compCreateExpr); IDataStructure expectedStructure = ModelResolvers.DsResolver(); for (int k = 2; k <= i; k++) { IExpression idExpr = ModelResolvers.ExprResolver(); idExpr.ExpressionText = $"Id{k}"; idExpr.Structure = ModelResolvers.DsResolver($"Id{k}", ComponentType.Identifier, (BasicDataType)combination[k - 1]); compCreateExpr.AddOperand($"ds_{k}", idExpr); expectedStructure.AddStructure(compCreateExpr.Operands[$"ds_{k}"].Structure); } IDataStructure dataStructure = compCreateExpr.OperatorDefinition.GetOutputStructure(compCreateExpr); Assert.True(expectedStructure.EqualsObj(dataStructure)); } } }
public void GetOutputStructure_Group2ScalarsExpr_DataStructure(params TestExprType[] types) { IExpression compCreateExpr = this._exprFac.GetExpression("group", ExpressionFactoryNameTarget.OperatorSymbol); IExpression idExpr1 = ModelResolvers.ExprResolver(); IExpression idExpr2 = ModelResolvers.ExprResolver(); idExpr1.ExpressionText = "Id1"; idExpr2.ExpressionText = "Id2"; idExpr1.Structure = ModelResolvers.DsResolver("Id1", ComponentType.Identifier, (BasicDataType)types[0]); idExpr2.Structure = ModelResolvers.DsResolver("Id2", ComponentType.Identifier, (BasicDataType)types[1]); compCreateExpr.AddOperand("ds_1", idExpr1); compCreateExpr.AddOperand("ds_2", idExpr2); IJoinExpression joinExpr = ModelResolvers.JoinExprResolver(this._exprFac.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol)); joinExpr.AddOperand("ds_1", compCreateExpr); IDataStructure expectedStructure = compCreateExpr.Operands["ds_1"].Structure.GetCopy(); expectedStructure.Identifiers.Add(compCreateExpr.Operands["ds_2"].Structure.GetCopy().Identifiers[0]); IDataStructure dataStructure = compCreateExpr.OperatorDefinition.GetOutputStructure(compCreateExpr); Assert.True(expectedStructure.EqualsObj(dataStructure)); }
public void GetOutputStructure_CalcComponentExpr_DataStructure(string keyword) { IExpression calcExpr = ModelResolvers.ExprResolver(); IExpression compExpr = ModelResolvers.ExprResolver(); compExpr.ExpressionText = "component"; compExpr.OperatorDefinition = ModelResolvers.OperatorResolver("comp"); calcExpr.OperatorDefinition = ModelResolvers.OperatorResolver("calcExpr"); calcExpr.OperatorDefinition.Keyword = keyword; calcExpr.AddOperand("ds_1", compExpr); ComponentType compType; switch (keyword) { case "identifier": compType = ComponentType.Identifier; break; case "measure": compType = ComponentType.Measure; break; case "attribute": compType = ComponentType.NonViralAttribute; break; case "viral attribute": compType = ComponentType.ViralAttribute; break; default: throw new ArgumentOutOfRangeException("keyword"); } IDataStructure dataStructure = compExpr.OperatorDefinition.GetOutputStructure(compExpr); Assert.True(dataStructure.IsSingleComponent); Assert.Equal(compType, dataStructure.Components[0].ComponentType); }
public void GetExpressions_Expressions() { TransformationSchema schema = new TransformationSchema(); IExpression expr1 = ModelResolvers.ExprResolver(); IExpression expr2 = ModelResolvers.ExprResolver(); AssignmentObject assignmentObject1 = new AssignmentObject(schema, expr1, true, new List <string>()); AssignmentObject assignmentObject2 = new AssignmentObject(schema, expr2, true, new List <string>()); schema.AssignmentObjects.Add(assignmentObject1); schema.AssignmentObjects.Add(assignmentObject2); List <IExpression> expected = new List <IExpression>() { expr1, expr2 }; ICollection <IExpression> result = schema.GetExpressions(); Assert.Equal(expected.Count, result.Count); for (int i = 0; i < expected.Count; i++) { Assert.Equal(expected[i], result.ToArray()[i]); } }
public DsBranchTests() { Mock <IExpressionTextGenerator> exprTextGeneratorMock = new Mock <IExpressionTextGenerator>(); exprTextGeneratorMock.Setup(etg => etg.GenerateRecursively(It.IsAny <IExpression>())) .Callback((IExpression expr) => { expr.ExpressionText = "Generated text"; }); this._exprTextGenerator = exprTextGeneratorMock.Object; Mock <IExpressionFactory> exprFactoryMock = new Mock <IExpressionFactory>(); exprFactoryMock.SetupGet(e => e.OperatorResolver).Returns(ModelResolvers.OperatorResolver); exprFactoryMock.SetupGet(e => e.ExprResolver).Returns(ModelResolvers.ExprResolver); exprFactoryMock.Setup(e => e.GetExpression(It.IsAny <string>(), ExpressionFactoryNameTarget.OperatorSymbol)).Returns((string opSymbol, ExpressionFactoryNameTarget nameTarget) => { IExpression expr = ModelResolvers.ExprResolver(); Mock <IOperatorDefinition> opDefMock = new Mock <IOperatorDefinition>(); opDefMock.SetupGet(opDef => opDef.Symbol).Returns(opSymbol); opDefMock.Setup(opDef => opDef.GetOutputStructure(It.IsAny <IExpression>())).Returns(ModelResolvers.DsResolver()); expr.OperatorDefinition = opDefMock.Object; return(expr); }); this._exprFac = exprFactoryMock.Object; }
public void GetFirstAncestorExpr_FirstAncestorExpr() { IExpression grandGrandExpr = ModelResolvers.ExprResolver(); IExpression grandExpr = ModelResolvers.ExprResolver(grandGrandExpr); IExpression fatherExpr = ModelResolvers.ExprResolver(grandExpr); Expression expr = new Expression(fatherExpr); Assert.Equal(grandGrandExpr, expr.GetFirstAncestorExpr()); }
public void GetAliasExpression_NoDsBranch_ThrowsException() { JoinExpression joinExpr = new JoinExpression(TestExprFactory.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol)); joinExpr.AddOperand("ds_1", ModelResolvers.ExprResolver()); joinExpr.AddOperand("ds_2", ModelResolvers.ExprResolver()); Assert.ThrowsAny <Exception>(() => { joinExpr.GetAliasExpression("ds_1"); }); }
public void GetOutputStructure_WrongExpr_ThrowsException() { IExpression getExpr = ModelResolvers.ExprResolver(); getExpr.ExpressionText = "Dataset"; getExpr.OperatorDefinition = this._opResolver("get"); Assert.ThrowsAny <Exception>(() => { getExpr.OperatorDefinition.GetOutputStructure(getExpr); }); }
public void GetOutputStructure_WrongExpr_ThrowsException(string exprText) { IExpression constExpr = ModelResolvers.ExprResolver(); constExpr.ExpressionText = exprText; constExpr.OperatorDefinition = ModelResolvers.OperatorResolver("const"); Assert.ThrowsAny <VtlOperatorError>(() => { constExpr.OperatorDefinition.GetOutputStructure(constExpr); }); }
public void GetFirstAncestorExpr_Name_FirstAncestorExprWithGivenName() { IExpression grandGrandExpr = ModelResolvers.ExprResolver(); IExpression grandExpr = ModelResolvers.ExprResolver(grandGrandExpr); IExpression fatherExpr = ModelResolvers.ExprResolver(grandExpr); Expression expr = new Expression(fatherExpr); grandExpr.ResultName = "GrandExpr"; Assert.Equal(grandExpr, expr.GetFirstAncestorExpr("GrandExpr")); }
public void Build_CrossJoinWithUsinngBranch_ThrowsException() { JoinBuilder joinBuilder = new JoinBuilder(ModelResolvers.JoinExprResolver, this.joinBranches); joinBuilder.AddMainExpr(TestExprFactory.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol)); joinBuilder.AddBranch("ds", ModelResolvers.ExprResolver()); joinBuilder.AddBranch("using", ModelResolvers.ExprResolver()); joinBuilder.Branches["main"].OperatorDefinition.Keyword = "cross"; Assert.ThrowsAny <VtlOperatorError>(() => { joinBuilder.Build(); }); }
public void BuildBranch_ExistingBranchBuilder_AddsBranch(string branch) { JoinBuilder joinBuilder = new JoinBuilder(ModelResolvers.JoinExprResolver, this.joinBranches); Assert.Empty(joinBuilder.Branches); IExpression result = joinBuilder.BuildBranch(branch, ModelResolvers.ExprResolver()); Assert.True(joinBuilder.Branches.ContainsKey(branch)); Assert.Equal(result, joinBuilder.Branches[branch]); }
public void Generate_IfThenElseExpr_CorrectText(string resultName) { IExpression expr = TestExprFactory.GetExpression(resultName, ExpressionFactoryNameTarget.ResultName); expr.AddOperand("ds_1", ModelResolvers.ExprResolver()); string exprText = expr.Operands["ds_1"].ExpressionText = "expr1"; this._exprTextGenerator.Generate(expr); Assert.Equal($"{resultName.ToLower()} {exprText}", expr.ExpressionText); }
public void GetOutputStructure_CorrectExpr_DataStructure() { IExpression getExpr = ModelResolvers.ExprResolver(); getExpr.ExpressionText = "IntsDataset"; getExpr.OperatorDefinition = this._opResolver("get"); IDataStructure dataStructure = getExpr.OperatorDefinition.GetOutputStructure(getExpr); Assert.True(TestExprFactory.GetExpression(TestExprType.IntsDataset).Structure.EqualsObj(dataStructure)); }
public void GetOutputStructure_WrongComponentType(ComponentType wrongType) { IExpression expr = ModelResolvers.ExprResolver(); expr.OperatorDefinition = ModelResolvers.OperatorResolver("sub"); IExpression operand = TestExprFactory.GetDatasetExpr(new KeyValuePair <ComponentType, BasicDataType>(wrongType, BasicDataType.Integer)); expr.AddOperand("ds_1", operand); Assert.ThrowsAny <Exception>(() => { expr.OperatorDefinition.GetOutputStructure(expr); }); }
public void GetOutputStructure_CorrectExpr_CorrectScalarStructure(TestExprType expectedType, string exprText) { IExpression constExpr = ModelResolvers.ExprResolver(); constExpr.ExpressionText = exprText; constExpr.OperatorDefinition = ModelResolvers.OperatorResolver("const"); IDataStructure dataStructure = constExpr.OperatorDefinition.GetOutputStructure(constExpr); Assert.True(TestExprFactory.GetExpression(expectedType).Structure.EqualsObj(dataStructure)); }
public void AddBranch_Expr_AddsBranch() { JoinBuilder joinBuilder = new JoinBuilder(ModelResolvers.JoinExprResolver, this.joinBranches); IExpression expr = ModelResolvers.ExprResolver(); Assert.False(joinBuilder.Branches.ContainsKey("branch")); joinBuilder.AddBranch("branch", expr); Assert.True(joinBuilder.Branches.ContainsKey("branch")); Assert.Equal(expr, joinBuilder.Branches["branch"]); Assert.False(joinBuilder.IsCleared); }
public void AddOperand_ExpressionWithExistingSignature_OverridesOperand() { Expression operandExpr = new Expression(); Expression expr = new Expression(); expr.AddOperand("ds_1", ModelResolvers.ExprResolver()); expr.AddOperand("ds_1", operandExpr); Assert.Equal(1, expr.OperandsCollection.Count); Assert.Equal(1, expr.Operands.Count); Assert.Equal(operandExpr, expr.OperandsCollection.First()); Assert.Equal(operandExpr, expr.Operands.First().Value); }
public void GetOutputStructure_CorrectExpr_DataStructure(TestExprType type) { foreach (string opSymbol in this._operators) { IExpression unaryArithmeticExpr = ModelResolvers.ExprResolver(); unaryArithmeticExpr.OperatorDefinition = ModelResolvers.OperatorResolver(opSymbol); unaryArithmeticExpr.AddOperand("ds_1", TestExprFactory.GetExpression(type)); IDataStructure dataStructure = unaryArithmeticExpr.OperatorDefinition.GetOutputStructure(unaryArithmeticExpr); Assert.True(unaryArithmeticExpr.Operands["ds_1"].Structure.EqualsObj(dataStructure)); } }
public void GetOutputStructure_Correct1Operand() { IExpression expr = ModelResolvers.ExprResolver(); expr.OperatorDefinition = ModelResolvers.OperatorResolver("sub"); IExpression operand = TestExprFactory.GetDatasetExpr(new KeyValuePair <ComponentType, BasicDataType>(ComponentType.Identifier, BasicDataType.Integer)); expr.AddOperand("ds_1", operand); IDataStructure dataStructure = expr.OperatorDefinition.GetOutputStructure(expr); Assert.True(operand.Structure.EqualsObj(dataStructure)); }
public void GetOutputStructure_Wrong() { IExpression expr = ModelResolvers.ExprResolver(); expr.OperatorDefinition = ModelResolvers.OperatorResolver("subExpr"); IExpression compExpr = TestExprFactory.GetDatasetExpr(new KeyValuePair <ComponentType, BasicDataType>(ComponentType.Identifier, BasicDataType.String)); IExpression constExpr = TestExprFactory.GetDatasetExpr(new KeyValuePair <ComponentType, BasicDataType>(ComponentType.Measure, BasicDataType.Integer)); expr.AddOperand("ds_1", compExpr); expr.AddOperand("ds_2", constExpr); Assert.ThrowsAny <Exception>(() => { expr.OperatorDefinition.GetOutputStructure(expr); }); }