mudhorn/prometheus
1
0
Fork 0
mirror of https://github.com/prometheus/prometheus.git synced 2024-11-13 17:14:05 -08:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity
prometheus/promql/lex_test.go

712 lines
17 KiB
Go
Raw Normal View History

Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
// Copyright 2015 The Prometheus Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package promql
import (
Enhance lexer testing output
2015-05-12 01:39:10 -07:00
"fmt"
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
"reflect"
"testing"
)
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
type testCase struct {
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
input string
expected []item
fail bool
seriesDesc bool // Whether to lex a series description.
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}
var tests = []struct {
name string
tests []testCase
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}{
{
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
name: "common",
tests: []testCase{
{
input: ",",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemComma, 0, ","}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "()",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemLeftParen, 0, `(`}, {ItemRightParen, 1, `)`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "{}",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemLeftBrace, 0, `{`}, {ItemRightBrace, 1, `}`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "[5m]",
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemLeftBracket, 0, `[`},
{ItemDuration, 1, `5m`},
{ItemRightBracket, 3, `]`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
}, {
input: "\r\n\r",
expected: []item{},
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
{
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
name: "numbers",
tests: []testCase{
{
input: "1",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemNumber, 0, "1"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "4.23",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemNumber, 0, "4.23"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: ".3",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemNumber, 0, ".3"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "5.",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemNumber, 0, "5."}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "NaN",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemNumber, 0, "NaN"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "nAN",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemNumber, 0, "nAN"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "NaN 123",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemNumber, 0, "NaN"}, {ItemNumber, 4, "123"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "NaN123",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemIdentifier, 0, "NaN123"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "iNf",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemNumber, 0, "iNf"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "Inf",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemNumber, 0, "Inf"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "+Inf",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemADD, 0, "+"}, {ItemNumber, 1, "Inf"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "+Inf 123",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemADD, 0, "+"}, {ItemNumber, 1, "Inf"}, {ItemNumber, 5, "123"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "-Inf",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemSUB, 0, "-"}, {ItemNumber, 1, "Inf"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "Infoo",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemIdentifier, 0, "Infoo"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "-Infoo",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemSUB, 0, "-"}, {ItemIdentifier, 1, "Infoo"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "-Inf 123",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemSUB, 0, "-"}, {ItemNumber, 1, "Inf"}, {ItemNumber, 5, "123"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "0x123",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemNumber, 0, "0x123"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
Add tests to specify the string escaping behavior
2016-03-01 14:23:18 -08:00
},
},
{
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
name: "strings",
tests: []testCase{
{
input: "\"test\\tsequence\"",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemString, 0, `"test\tsequence"`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
{
input: "\"test\\\\.expression\"",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemString, 0, `"test\\.expression"`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
{
input: "\"test\\.expression\"",
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemError, 0, "unknown escape sequence U+002E '.'"},
{ItemString, 0, `"test\.expression"`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
},
{
input: "`test\\.expression`",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemString, 0, "`test\\.expression`"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
{
// See https://github.com/prometheus/prometheus/issues/939.
input: ".٩",
fail: true,
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
{
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
name: "durations",
tests: []testCase{
{
input: "5s",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemDuration, 0, "5s"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "123m",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemDuration, 0, "123m"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "1h",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemDuration, 0, "1h"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "3w",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemDuration, 0, "3w"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "1y",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemDuration, 0, "1y"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
{
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
name: "identifiers",
tests: []testCase{
{
input: "abc",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemIdentifier, 0, "abc"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "a:bc",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemMetricIdentifier, 0, "a:bc"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "abc d",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemIdentifier, 0, "abc"}, {ItemIdentifier, 4, "d"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: ":bc",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemMetricIdentifier, 0, ":bc"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "0a:bc",
fail: true,
},
Fix single quote parsing, add tests
2015-05-08 07:43:02 -07:00
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
{
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
name: "comments",
tests: []testCase{
{
input: "# some comment",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemComment, 0, "# some comment"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "5 # 1+1\n5",
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemNumber, 0, "5"},
{ItemComment, 2, "# 1+1"},
{ItemNumber, 8, "5"},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
},
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
{
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
name: "operators",
tests: []testCase{
{
input: `=`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemAssign, 0, `=`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
// Inside braces equality is a single '=' character.
input: `{=}`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemLeftBrace, 0, `{`}, {ItemEQL, 1, `=`}, {ItemRightBrace, 2, `}`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `==`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemEQL, 0, `==`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `!=`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemNEQ, 0, `!=`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `<`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemLSS, 0, `<`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `>`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemGTR, 0, `>`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `>=`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemGTE, 0, `>=`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `<=`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemLTE, 0, `<=`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `+`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemADD, 0, `+`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `-`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemSUB, 0, `-`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `*`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemMUL, 0, `*`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `/`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemDIV, 0, `/`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `^`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemPOW, 0, `^`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `%`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemMOD, 0, `%`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `AND`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemLAND, 0, `AND`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `or`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemLOR, 0, `or`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `unless`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemLUnless, 0, `unless`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
Check for invalid utf-8 in lexer strings. This protects against invalid utf-8 sneaking in via label_replace.
2017-06-16 07:19:24 -07:00
{
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
name: "aggregators",
tests: []testCase{
{
input: `sum`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemSum, 0, `sum`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `AVG`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemAvg, 0, `AVG`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `MAX`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemMax, 0, `MAX`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `min`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemMin, 0, `min`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `count`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemCount, 0, `count`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `stdvar`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemStdvar, 0, `stdvar`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: `stddev`,
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemStddev, 0, `stddev`}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
},
Check for invalid utf-8 in lexer strings. This protects against invalid utf-8 sneaking in via label_replace.
2017-06-16 07:19:24 -07:00
},
{
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
name: "keywords",
tests: []testCase{
{
input: "offset",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemOffset, 0, "offset"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "by",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemBy, 0, "by"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "without",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemWithout, 0, "without"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "on",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemOn, 0, "on"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "ignoring",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemIgnoring, 0, "ignoring"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "group_left",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemGroupLeft, 0, "group_left"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "group_right",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemGroupRight, 0, "group_right"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
}, {
input: "bool",
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
expected: []item{{ItemBool, 0, "bool"}},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
},
Check for invalid utf-8 in lexer strings. This protects against invalid utf-8 sneaking in via label_replace.
2017-06-16 07:19:24 -07:00
},
Enhance lexer testing output
2015-05-12 01:39:10 -07:00
{
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
name: "selectors",
tests: []testCase{
{
input: `台北`,
fail: true,
}, {
input: `{台北='a'}`,
fail: true,
}, {
input: `{0a='a'}`,
fail: true,
}, {
input: `{foo='bar'}`,
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemLeftBrace, 0, `{`},
{ItemIdentifier, 1, `foo`},
{ItemEQL, 4, `=`},
{ItemString, 5, `'bar'`},
{ItemRightBrace, 10, `}`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
}, {
input: `{foo="bar"}`,
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemLeftBrace, 0, `{`},
{ItemIdentifier, 1, `foo`},
{ItemEQL, 4, `=`},
{ItemString, 5, `"bar"`},
{ItemRightBrace, 10, `}`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
}, {
input: `{foo="bar\"bar"}`,
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemLeftBrace, 0, `{`},
{ItemIdentifier, 1, `foo`},
{ItemEQL, 4, `=`},
{ItemString, 5, `"bar\"bar"`},
{ItemRightBrace, 15, `}`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
}, {
input: `{NaN != "bar" }`,
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemLeftBrace, 0, `{`},
{ItemIdentifier, 1, `NaN`},
{ItemNEQ, 5, `!=`},
{ItemString, 8, `"bar"`},
{ItemRightBrace, 14, `}`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
}, {
input: `{alert=~"bar" }`,
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemLeftBrace, 0, `{`},
{ItemIdentifier, 1, `alert`},
{ItemEQLRegex, 6, `=~`},
{ItemString, 8, `"bar"`},
{ItemRightBrace, 14, `}`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
}, {
input: `{on!~"bar"}`,
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemLeftBrace, 0, `{`},
{ItemIdentifier, 1, `on`},
{ItemNEQRegex, 3, `!~`},
{ItemString, 5, `"bar"`},
{ItemRightBrace, 10, `}`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
}, {
input: `{alert!#"bar"}`, fail: true,
}, {
input: `{foo:a="bar"}`, fail: true,
},
Enhance lexer testing output
2015-05-12 01:39:10 -07:00
},
},
{
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
name: "common errors",
tests: []testCase{
{
input: `=~`, fail: true,
}, {
input: `!~`, fail: true,
}, {
input: `!(`, fail: true,
}, {
input: "1a", fail: true,
},
Enhance lexer testing output
2015-05-12 01:39:10 -07:00
},
},
{
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
name: "mismatched parentheses",
tests: []testCase{
{
input: `(`, fail: true,
}, {
input: `())`, fail: true,
}, {
input: `(()`, fail: true,
}, {
input: `{`, fail: true,
}, {
input: `}`, fail: true,
}, {
input: "{{", fail: true,
}, {
input: "{{}}", fail: true,
}, {
input: `[`, fail: true,
}, {
input: `[[`, fail: true,
}, {
input: `[]]`, fail: true,
}, {
input: `[[]]`, fail: true,
}, {
input: `]`, fail: true,
},
Enhance lexer testing output
2015-05-12 01:39:10 -07:00
},
},
Subquery (#4831) Signed-off-by: Ganesh Vernekar <cs15btech11018@iith.ac.in>
2018-12-22 05:47:13 -08:00
{
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
name: "encoding issues",
tests: []testCase{
{
input: "\"\xff\"", fail: true,
},
{
input: "`\xff`", fail: true,
},
Subquery (#4831) Signed-off-by: Ganesh Vernekar <cs15btech11018@iith.ac.in>
2018-12-22 05:47:13 -08:00
},
},
{
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
name: "series descriptions",
tests: []testCase{
{
input: `{} _ 1 x .3`,
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemLeftBrace, 0, `{`},
{ItemRightBrace, 1, `}`},
{ItemSpace, 2, ` `},
{ItemBlank, 3, `_`},
{ItemSpace, 4, ` `},
{ItemNumber, 5, `1`},
{ItemSpace, 6, ` `},
{ItemTimes, 7, `x`},
{ItemSpace, 8, ` `},
{ItemNumber, 9, `.3`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
seriesDesc: true,
},
{
input: `metric +Inf Inf NaN`,
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemIdentifier, 0, `metric`},
{ItemSpace, 6, ` `},
{ItemADD, 7, `+`},
{ItemNumber, 8, `Inf`},
{ItemSpace, 11, ` `},
{ItemNumber, 12, `Inf`},
{ItemSpace, 15, ` `},
{ItemNumber, 16, `NaN`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
seriesDesc: true,
},
{
input: `metric 1+1x4`,
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemIdentifier, 0, `metric`},
{ItemSpace, 6, ` `},
{ItemNumber, 7, `1`},
{ItemADD, 8, `+`},
{ItemNumber, 9, `1`},
{ItemTimes, 10, `x`},
{ItemNumber, 11, `4`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
seriesDesc: true,
},
Subquery (#4831) Signed-off-by: Ganesh Vernekar <cs15btech11018@iith.ac.in>
2018-12-22 05:47:13 -08:00
},
},
{
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
name: "subqueries",
tests: []testCase{
{
input: `test_name{on!~"bar"}[4m:4s]`,
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemIdentifier, 0, `test_name`},
{ItemLeftBrace, 9, `{`},
{ItemIdentifier, 10, `on`},
{ItemNEQRegex, 12, `!~`},
{ItemString, 14, `"bar"`},
{ItemRightBrace, 19, `}`},
{ItemLeftBracket, 20, `[`},
{ItemDuration, 21, `4m`},
{ItemColon, 23, `:`},
{ItemDuration, 24, `4s`},
{ItemRightBracket, 26, `]`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
},
{
input: `test:name{on!~"bar"}[4m:4s]`,
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemMetricIdentifier, 0, `test:name`},
{ItemLeftBrace, 9, `{`},
{ItemIdentifier, 10, `on`},
{ItemNEQRegex, 12, `!~`},
{ItemString, 14, `"bar"`},
{ItemRightBrace, 19, `}`},
{ItemLeftBracket, 20, `[`},
{ItemDuration, 21, `4m`},
{ItemColon, 23, `:`},
{ItemDuration, 24, `4s`},
{ItemRightBracket, 26, `]`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
}, {
input: `test:name{on!~"b:ar"}[4m:4s]`,
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemMetricIdentifier, 0, `test:name`},
{ItemLeftBrace, 9, `{`},
{ItemIdentifier, 10, `on`},
{ItemNEQRegex, 12, `!~`},
{ItemString, 14, `"b:ar"`},
{ItemRightBrace, 20, `}`},
{ItemLeftBracket, 21, `[`},
{ItemDuration, 22, `4m`},
{ItemColon, 24, `:`},
{ItemDuration, 25, `4s`},
{ItemRightBracket, 27, `]`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
}, {
input: `test:name{on!~"b:ar"}[4m:]`,
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemMetricIdentifier, 0, `test:name`},
{ItemLeftBrace, 9, `{`},
{ItemIdentifier, 10, `on`},
{ItemNEQRegex, 12, `!~`},
{ItemString, 14, `"b:ar"`},
{ItemRightBrace, 20, `}`},
{ItemLeftBracket, 21, `[`},
{ItemDuration, 22, `4m`},
{ItemColon, 24, `:`},
{ItemRightBracket, 25, `]`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
}, { // Nested Subquery.
input: `min_over_time(rate(foo{bar="baz"}[2s])[5m:])[4m:3s]`,
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemIdentifier, 0, `min_over_time`},
{ItemLeftParen, 13, `(`},
{ItemIdentifier, 14, `rate`},
{ItemLeftParen, 18, `(`},
{ItemIdentifier, 19, `foo`},
{ItemLeftBrace, 22, `{`},
{ItemIdentifier, 23, `bar`},
{ItemEQL, 26, `=`},
{ItemString, 27, `"baz"`},
{ItemRightBrace, 32, `}`},
{ItemLeftBracket, 33, `[`},
{ItemDuration, 34, `2s`},
{ItemRightBracket, 36, `]`},
{ItemRightParen, 37, `)`},
{ItemLeftBracket, 38, `[`},
{ItemDuration, 39, `5m`},
{ItemColon, 41, `:`},
{ItemRightBracket, 42, `]`},
{ItemRightParen, 43, `)`},
{ItemLeftBracket, 44, `[`},
{ItemDuration, 45, `4m`},
{ItemColon, 47, `:`},
{ItemDuration, 48, `3s`},
{ItemRightBracket, 50, `]`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
},
// Subquery with offset.
{
input: `test:name{on!~"b:ar"}[4m:4s] offset 10m`,
expected: []item{
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemMetricIdentifier, 0, `test:name`},
{ItemLeftBrace, 9, `{`},
{ItemIdentifier, 10, `on`},
{ItemNEQRegex, 12, `!~`},
{ItemString, 14, `"b:ar"`},
{ItemRightBrace, 20, `}`},
{ItemLeftBracket, 21, `[`},
{ItemDuration, 22, `4m`},
{ItemColon, 24, `:`},
{ItemDuration, 25, `4s`},
{ItemRightBracket, 27, `]`},
{ItemOffset, 29, "offset"},
{ItemDuration, 36, "10m"},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
}, {
input: `min_over_time(rate(foo{bar="baz"}[2s])[5m:] offset 6m)[4m:3s]`,
expected: []item{
Subquery (#4831) Signed-off-by: Ganesh Vernekar <cs15btech11018@iith.ac.in>
2018-12-22 05:47:13 -08:00
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
{ItemIdentifier, 0, `min_over_time`},
{ItemLeftParen, 13, `(`},
{ItemIdentifier, 14, `rate`},
{ItemLeftParen, 18, `(`},
{ItemIdentifier, 19, `foo`},
{ItemLeftBrace, 22, `{`},
{ItemIdentifier, 23, `bar`},
{ItemEQL, 26, `=`},
{ItemString, 27, `"baz"`},
{ItemRightBrace, 32, `}`},
{ItemLeftBracket, 33, `[`},
{ItemDuration, 34, `2s`},
{ItemRightBracket, 36, `]`},
{ItemRightParen, 37, `)`},
{ItemLeftBracket, 38, `[`},
{ItemDuration, 39, `5m`},
{ItemColon, 41, `:`},
{ItemRightBracket, 42, `]`},
{ItemOffset, 44, `offset`},
{ItemDuration, 51, `6m`},
{ItemRightParen, 53, `)`},
{ItemLeftBracket, 54, `[`},
{ItemDuration, 55, `4m`},
{ItemColon, 57, `:`},
{ItemDuration, 58, `3s`},
{ItemRightBracket, 60, `]`},
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
},
},
{
input: `test:name{o:n!~"bar"}[4m:4s]`,
fail: true,
},
{
input: `test:name{on!~"bar"}[4m:4s:4h]`,
fail: true,
},
{
input: `test:name{on!~"bar"}[4m:4s:]`,
fail: true,
},
{
input: `test:name{on!~"bar"}[4m::]`,
fail: true,
},
{
input: `test:name{on!~"bar"}[:4s]`,
fail: true,
},
Subquery (#4831) Signed-off-by: Ganesh Vernekar <cs15btech11018@iith.ac.in>
2018-12-22 05:47:13 -08:00
},
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}
// TestLexer tests basic functionality of the lexer. More elaborate tests are implemented
// for the parser to avoid duplicated effort.
func TestLexer(t *testing.T) {
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
for _, typ := range tests {
t.Run(typ.name, func(t *testing.T) {
for i, test := range typ.tests {
l := &lexer{
input: test.input,
items: make(chan item),
seriesDesc: test.seriesDesc,
}
go l.run()
Instantiate lexer inline for the test Don't use the lex constructor, remove the constructor introduced in the prevous commit.
2016-08-29 00:20:43 -07:00
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
out := []item{}
for it := range l.items {
out = append(out, it)
}
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
lastItem := out[len(out)-1]
if test.fail {
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
if lastItem.typ != ItemError {
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
t.Logf("%d: input %q", i, test.input)
t.Fatalf("expected lexing error but did not fail")
}
continue
}
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
if lastItem.typ == ItemError {
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
t.Logf("%d: input %q", i, test.input)
t.Fatalf("unexpected lexing error at position %d: %s", lastItem.pos, lastItem)
}
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
Expose lexer item types (#5358) * Expose lexer item types We have generally agreed to expose AST types / values that are necessary to make sense of the AST outside of the promql package. Currently the `UnaryExpr`, `BinaryExpr`, and `AggregateExpr` AST nodes store the lexer item type to indicate the operator type, but since the individual item types aren't exposed, an external user of the package cannot determine the operator type. So this PR exposes them. Although not all item types are required to make sense of the AST (some are really only used in the lexer), I decided to expose them all here to be somewhat more consistent. Another option would be to not use lexer item types at all in AST nodes. The concrete motivation is my work on the PromQL->Flux transpiler, but this ought to be useful for other cases as well. Signed-off-by: Julius Volz <julius.volz@gmail.com> * Fix item type names in tests Signed-off-by: Julius Volz <julius.volz@gmail.com>
2019-03-14 12:53:55 -07:00
if !reflect.DeepEqual(lastItem, item{ItemEOF, Pos(len(test.input)), ""}) {
promql: use subtests in TestLexer Signed-off-by: Matt Layher <mdlayher@gmail.com>
2019-01-16 13:35:45 -08:00
t.Logf("%d: input %q", i, test.input)
t.Fatalf("lexing error: expected output to end with EOF item.\ngot:\n%s", expectedList(out))
}
out = out[:len(out)-1]
if !reflect.DeepEqual(out, test.expected) {
t.Logf("%d: input %q", i, test.input)
t.Fatalf("lexing mismatch:\nexpected:\n%s\ngot:\n%s", expectedList(test.expected), expectedList(out))
}
}
})
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}
}
Enhance lexer testing output
2015-05-12 01:39:10 -07:00
func expectedList(exp []item) string {
s := ""
for _, it := range exp {
s += fmt.Sprintf("\t%#v\n", it)
}
return s
}
Reference in a new issue Copy permalink