public void Generate_IfOperator_CorrectText()
{
for (int i = 0; i < 2; i++)
{
IExpression expr = this.GetExpr("if");
expr.Operands.Clear();
expr.Operands.Add("if", TestExprFactory.GetExpression("If", ExpressionFactoryNameTarget.ResultName));
expr.Operands.Add("then", TestExprFactory.GetExpression("Then", ExpressionFactoryNameTarget.ResultName));
string expr1Text = expr.Operands["if"].ExpressionText = "expr1";
string expr2Text = expr.Operands["then"].ExpressionText = "expr2";
string expected = $"{expr1Text} {expr2Text}";
if (i == 1)
{
expr.Operands.Add("else", TestExprFactory.GetExpression("Else", ExpressionFactoryNameTarget.ResultName));
string expr3Text = expr.Operands["else"].ExpressionText = "expr3";
expected += $" {expr3Text}";
}
this._exprTextGenerator.Generate(expr);
Assert.Equal(expected, expr.ExpressionText);
}
}
public void GetOutputStructure_WrongArgsExpr_ThrowsException()
{
TestExprType[][] correctCombs = new TestExprType[][] {
new TestExprType[] { TestExprType.String, TestExprType.String },
new TestExprType[] { TestExprType.String, TestExprType.None },
new TestExprType[] { TestExprType.None, TestExprType.String },
new TestExprType[] { TestExprType.None, TestExprType.None },
new TestExprType[] { TestExprType.StringsDataset, TestExprType.String },
new TestExprType[] { TestExprType.StringsDataset, TestExprType.None },
new TestExprType[] { TestExprType.NonesDataset, TestExprType.String },
new TestExprType[] { TestExprType.NonesDataset, TestExprType.None }
};
TestExprType[][] combinations = Enum.GetValues(typeof(TestExprType)).Cast <TestExprType>().GetCombinations(2);
TestExprType[][] wrongCombs = combinations.Without(correctCombs);
foreach (TestExprType[] wrongComb in wrongCombs.Where(wrongComb => (int)wrongComb[0] < 18 && (int)wrongComb[1] < 18)) // No mixed datasets
{
IExpression stringExpr = TestExprFactory.GetExpression(wrongComb);
stringExpr.OperatorDefinition = ModelResolvers.OperatorResolver("match_characters");
if (!stringExpr.Operands["ds_1"].IsScalar)
{
stringExpr.Operands["ds_1"].Structure.Measures.RemoveAt(1);
}
if (!stringExpr.Operands["ds_2"].IsScalar)
{
stringExpr.Operands["ds_2"].Structure.Measures.RemoveAt(1);
}
// Debug condition example: wrongComb[0] == TestExprType.Integer && wrongComb[1] == TestExprType.Integer
Assert.ThrowsAny <VtlOperatorError>(() => { stringExpr.OperatorDefinition.GetOutputStructure(stringExpr); });
}
}
public void GetOutputStructure_MultiMeasuresDatasetExpr_ThrowsException()
{
TestExprType[][] scalars = new TestExprType[][] {
new TestExprType[] { TestExprType.Integer },
new TestExprType[] { TestExprType.Number },
new TestExprType[] { TestExprType.String },
new TestExprType[] { TestExprType.Boolean },
new TestExprType[] { TestExprType.Time },
new TestExprType[] { TestExprType.Date },
new TestExprType[] { TestExprType.TimePeriod },
new TestExprType[] { TestExprType.Duration },
new TestExprType[] { TestExprType.None }
};
TestExprType[][] types = Enum.GetValues(typeof(TestExprType)).Cast <TestExprType>().GetCombinations(1);
TestExprType[][] datasets = types.Without(scalars);
foreach (TestExprType[] dataset in datasets)
{
IExpression isNullExpr = TestExprFactory.GetExpression(dataset);
isNullExpr.OperatorDefinition = ModelResolvers.OperatorResolver("isnull");
// Debug condition example: dataset[0] == TestExprType.IntsDataset
Assert.ThrowsAny <VtlOperatorError>(() => { isNullExpr.OperatorDefinition.GetOutputStructure(isNullExpr); });
}
}
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 GetOutputStructure_WrongArgExpr1Arg_ThrowsException(string opSymbol)
{
TestExprType[][] correctCombs = new TestExprType[][] {
new TestExprType[] { TestExprType.String },
new TestExprType[] { TestExprType.None },
new TestExprType[] { TestExprType.StringsDataset },
new TestExprType[] { TestExprType.NonesDataset },
new TestExprType[] { TestExprType.MixedNoneStrDataset }
};
TestExprType[][] combinations = Enum.GetValues(typeof(TestExprType)).Cast <TestExprType>().GetCombinations(1);
TestExprType[][] wrongCombs = combinations.Without(correctCombs.ToArray());
foreach (TestExprType[] wrongComb in wrongCombs.Where(wrongComb => (int)wrongComb[0] < 18)) // No mixed datasets
{
IExpression stringExpr = TestExprFactory.GetExpression(new TestExprType[] { wrongComb[0] });
stringExpr.OperatorDefinition = ModelResolvers.OperatorResolver(opSymbol);
if (opSymbol.In("length", "instr") && stringExpr.Operands["ds_1"].Structure.Measures.Count > 1)
{
stringExpr.Operands["ds_1"].Structure.Measures.RemoveAt(1);
}
// Debug condition example: wrongComb[0] == TestExprType.Integer
Assert.ThrowsAny <VtlOperatorError>(() => { stringExpr.OperatorDefinition.GetOutputStructure(stringExpr); });
}
}
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_NScalarsExpr_DataStructure(string opSymbol)
{
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 = TestExprFactory.GetExpression(combination);
compCreateExpr.OperatorDefinition = this._exprFac.OperatorResolver(opSymbol);
joinExpr.AddOperand("ds_1", compCreateExpr);
IDataStructure expectedStructure = compCreateExpr.Operands["ds_1"].Structure.GetCopy();
for (int k = 2; k <= i; k++)
{
expectedStructure.AddStructure(compCreateExpr.Operands[$"ds_{k}"].Structure);
}
IDataStructure dataStructure = compCreateExpr.OperatorDefinition.GetOutputStructure(compCreateExpr);
Assert.True(expectedStructure.EqualsObj(dataStructure));
}
}
}
public void GetOutputStructure_Correct1Superset1SubsetExpr_SupersetModified(params TestExprType[] types)
{
foreach (string opSymbol in this._operators)
{
IExpression arithmeticExpr = TestExprFactory.GetExpression(types);
arithmeticExpr.OperatorDefinition = ModelResolvers.OperatorResolver(opSymbol);
arithmeticExpr.Operands["ds_1"].Structure.Identifiers.Add(new StructureComponent(BasicDataType.Integer, "Id2"));
IDataStructure expectedStructure = arithmeticExpr.Operands[$"ds_1"].Structure.GetCopy();
for (int i = 0; i < expectedStructure.Measures.Count; i++)
{
BasicDataType dataType = arithmeticExpr.Operands[$"ds_2"].Structure.Measures[i].ValueDomain.DataType;
if (dataType == BasicDataType.Number)
{
expectedStructure.Measures[i].ValueDomain = new ValueDomain(dataType);
}
if (expectedStructure.Measures[i].ValueDomain.DataType == BasicDataType.None)
{
expectedStructure.Measures[i].ValueDomain = new ValueDomain(BasicDataType.Integer);
}
}
IDataStructure dataStructure = arithmeticExpr.OperatorDefinition.GetOutputStructure(arithmeticExpr);
Assert.True(expectedStructure.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 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 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 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 GetOutputStructure_WrongArgExpr_ThrowsException()
{
TestExprType[][] correctCombs = new TestExprType[][] {
new TestExprType[] { TestExprType.Integer },
new TestExprType[] { TestExprType.Number },
new TestExprType[] { TestExprType.None },
new TestExprType[] { TestExprType.IntsDataset },
new TestExprType[] { TestExprType.NumbersDataset },
new TestExprType[] { TestExprType.MixedIntNumDataset },
new TestExprType[] { TestExprType.NonesDataset },
new TestExprType[] { TestExprType.MixedNoneIntDataset },
new TestExprType[] { TestExprType.MixedNoneNumDataset }
};
TestExprType[][] combinations = Enum.GetValues(typeof(TestExprType)).Cast <TestExprType>().GetCombinations(1);
TestExprType[][] wrongCombs = combinations.Without(correctCombs);
foreach (string opSymbol in this._operators)
{
foreach (TestExprType[] wrongComb in wrongCombs)
{
IExpression unaryArithmeticExpr = TestExprFactory.GetExpression(wrongComb);
unaryArithmeticExpr.OperatorDefinition = ModelResolvers.OperatorResolver(opSymbol);
// Debug condition example: wrongComb[0] == TestExprType.Integer
Assert.ThrowsAny <VtlOperatorError>(() => { unaryArithmeticExpr.OperatorDefinition.GetOutputStructure(unaryArithmeticExpr); });
}
}
}
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_CorrectSingleMeasureExpr_DataStructure(params TestExprType[] types)
{
IExpression nvlExpr = TestExprFactory.GetExpression(types[0], types[1]);
nvlExpr.OperatorDefinition = ModelResolvers.OperatorResolver("nvl");
if (nvlExpr.Operands["ds_1"].Structure.Measures.Count > 1)
{
nvlExpr.Operands["ds_1"].Structure.Measures.RemoveAt(1);
}
if (nvlExpr.Operands["ds_2"].Structure.Measures.Count > 1)
{
nvlExpr.Operands["ds_2"].Structure.Measures.RemoveAt(1);
}
IExpression expected = TestExprFactory.GetExpression(types[2]);
if (expected.Structure.Measures.Count > 1)
{
expected.Structure.Measures.RemoveAt(1);
}
IDataStructure dataStructure = nvlExpr.OperatorDefinition.GetOutputStructure(nvlExpr);
Assert.True(expected.Structure.EqualsObj(dataStructure));
}
public void CurrentJoinExpr_JoinExprAncestor_CorrectExpression()
{
IJoinExpression joinExpr = ModelResolvers.JoinExprResolver(TestExprFactory.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol));
Expression expr = new Expression(joinExpr);
Assert.Equal(joinExpr, expr.CurrentJoinExpr);
}
public void GetOutputStructure_WrongArgExpr_ThrowsException()
{
TestExprType[][] correctCombs = new TestExprType[][] {
new TestExprType[] { TestExprType.Boolean },
new TestExprType[] { TestExprType.None },
new TestExprType[] { TestExprType.BoolsDataset },
new TestExprType[] { TestExprType.NonesDataset },
};
TestExprType[][] combinations = Enum.GetValues(typeof(TestExprType)).Cast <TestExprType>().GetCombinations(1);
TestExprType[][] wrongCombs = combinations.Without(correctCombs);
foreach (TestExprType[] wrongComb in wrongCombs.Where(wrongComb => (int)wrongComb[0] < 18)) // No mixed datasets
{
IExpression notExpr = TestExprFactory.GetExpression(wrongComb);
notExpr.OperatorDefinition = ModelResolvers.OperatorResolver("not");
if (notExpr.Operands["ds_1"].Structure.Measures.Count > 1)
{
notExpr.Operands["ds_1"].Structure.Measures.RemoveAt(1);
}
// Debug condition example: wrongComb[0] == TestExprType.Integer
Assert.ThrowsAny <VtlOperatorError>(() => { notExpr.OperatorDefinition.GetOutputStructure(notExpr); });
}
}
public void GetOutputStructure_1MultiMeasuresDataset2CorrectScalarsArgsExpr_ThrowsException(params TestExprType[] types)
{
IExpression betweenExpr = TestExprFactory.GetExpression(types);
betweenExpr.OperatorDefinition = ModelResolvers.OperatorResolver("between");
Assert.ThrowsAny <VtlOperatorError>(() => { betweenExpr.OperatorDefinition.GetOutputStructure(betweenExpr); });
}
public void GetOutputStructure_MultiMeasuresDatasetNScalarsExpr_ThrowsException(string opSymbol, params TestExprType[] types)
{
IExpression stringExpr = TestExprFactory.GetExpression(types);
stringExpr.OperatorDefinition = ModelResolvers.OperatorResolver(opSymbol);
Assert.ThrowsAny <VtlOperatorError>(() => { stringExpr.OperatorDefinition.GetOutputStructure(stringExpr); });
}
public void GetOutputStructure_MultiMeasuresDatasetExpr_ThrowsException(TestExprType type)
{
IExpression notExpr = TestExprFactory.GetExpression(new TestExprType[] { type });
notExpr.OperatorDefinition = ModelResolvers.OperatorResolver("not");
Assert.ThrowsAny <VtlOperatorError>(() => { notExpr.OperatorDefinition.GetOutputStructure(notExpr); });
}
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 GetExpression_OperatorSymbol_ExprWithNameAndOpDefinition(string opSymbol)
{
IExpression expr = TestExprFactory.GetExpression(opSymbol, ExpressionFactoryNameTarget.OperatorSymbol);
Assert.Equal(opSymbol == "+" ? "Arithmetic" : "Comparison", expr.ResultName);
Assert.Null(expr.ExpressionText);
Assert.Equal(opSymbol, expr.OperatorSymbol);
Assert.NotNull(expr.OperatorDefinition);
}
public void GetExpression_ResultName_ExprWithName(string name)
{
IExpression expr = TestExprFactory.GetExpression(name, ExpressionFactoryNameTarget.ResultName);
Assert.Equal(name, expr.ResultName);
Assert.Null(expr.ExpressionText);
Assert.Null(expr.OperatorSymbol);
Assert.Null(expr.OperatorDefinition);
}
public void GetOutputStructure_CorrectScalarsExpr_NumberScalarStructure(string opSymbol, params TestExprType[] types)
{
IExpression numericExpr = TestExprFactory.GetExpression(types);
numericExpr.OperatorDefinition = ModelResolvers.OperatorResolver(opSymbol);
IDataStructure dataStructure = numericExpr.OperatorDefinition.GetOutputStructure(numericExpr);
Assert.True(TestExprFactory.GetExpression(TestExprType.Number).Structure.EqualsObj(dataStructure));
}
public void GetOutputStructure_Correct3ScalarsArgsExpr_BoolScalarStructure(params TestExprType[] types)
{
IExpression betweenExpr = TestExprFactory.GetExpression(types);
betweenExpr.OperatorDefinition = ModelResolvers.OperatorResolver("between");
IDataStructure dataStructure = betweenExpr.OperatorDefinition.GetOutputStructure(betweenExpr);
Assert.Equal(BasicDataType.Boolean, dataStructure.Components.First().ValueDomain.DataType);
}
public void GetOutputStructure_CorrectScalarExpr_BoolScalarStructure(TestExprType type)
{
IExpression notExpr = TestExprFactory.GetExpression(new TestExprType[] { type });
notExpr.OperatorDefinition = ModelResolvers.OperatorResolver("not");
IDataStructure dataStructure = notExpr.OperatorDefinition.GetOutputStructure(notExpr);
Assert.True(TestExprFactory.GetExpression(TestExprType.Boolean).Structure.EqualsObj(dataStructure));
}
public void GetOutputStructure_CorrectScalarsExpr_BoolScalarStructure(params TestExprType[] types)
{
IExpression stringExpr = TestExprFactory.GetExpression(types);
stringExpr.OperatorDefinition = ModelResolvers.OperatorResolver("match_characters");
IDataStructure dataStructure = stringExpr.OperatorDefinition.GetOutputStructure(stringExpr);
Assert.True(TestExprFactory.GetExpression(TestExprType.Boolean).Structure.EqualsObj(dataStructure));
}
public void GetOutputStructure_ScalarDatasetExpr_StringsDatasetStructure(string opSymbol, params TestExprType[] types)
{
IExpression stringExpr = TestExprFactory.GetExpression(types);
stringExpr.OperatorDefinition = ModelResolvers.OperatorResolver(opSymbol);
IDataStructure dataStructure = stringExpr.OperatorDefinition.GetOutputStructure(stringExpr);
Assert.True(TestExprFactory.GetExpression(TestExprType.StringsDataset).Structure.EqualsObj(dataStructure));
}
public void GetOutputStructure_1MultiMeasuresDataset1CorrectScalarArgsExpr_ThrowsException(params TestExprType[] types)
{
foreach (string opSymbol in this._operators)
{
IExpression equalityExpr = TestExprFactory.GetExpression(types);
equalityExpr.OperatorDefinition = ModelResolvers.OperatorResolver(opSymbol);
Assert.ThrowsAny <VtlOperatorError>(() => { equalityExpr.OperatorDefinition.GetOutputStructure(equalityExpr); });
}
}
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(); });
}