honeymoose
/
OpenSearch
mirror of https://github.com/honeymoose/OpenSearch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added a new scripting language (PlanA). 

Closes #15136
This commit is contained in:
Jack Conradson 2015-12-09 16:32:37 -08:00
parent 414fccb7d1
commit da5b07ae13
70 changed files with 19804 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
core/src/main/java/org/elasticsearch/plugins/PluginManager.java
View File

@ -83,6 +83,7 @@ public class PluginManager {
"discovery-gce", "discovery-gce",
"discovery-multicast", "discovery-multicast",
"lang-javascript", "lang-javascript",
"lang-plan-a",
"lang-python", "lang-python",
"mapper-attachments", "mapper-attachments",
"mapper-murmur3", "mapper-murmur3",

1
core/src/main/resources/org/elasticsearch/plugins/plugin-install.help
View File

@ -44,6 +44,7 @@ OFFICIAL PLUGINS
- discovery-gce - discovery-gce
- discovery-multicast - discovery-multicast
- lang-javascript - lang-javascript
- lang-plan-a
- lang-python - lang-python
- mapper-attachments - mapper-attachments
- mapper-murmur3 - mapper-murmur3

1
dev-tools/smoke_test_rc.py
View File

@ -70,6 +70,7 @@ DEFAULT_PLUGINS = ["analysis-icu",
"lang-expression", "lang-expression",
"lang-groovy", "lang-groovy",
"lang-javascript", "lang-javascript",
"lang-plan-a",
"lang-python", "lang-python",
"mapper-murmur3", "mapper-murmur3",
"mapper-size", "mapper-size",

145
plugins/lang-plan-a/ant.xml Normal file
View File

@ -0,0 +1,145 @@
<?xml version="1.0"?>
<project name="ant-stuff">
<!--
grammar regeneration logic
we do this with ant for several reasons:
* remove generated tabs for forbidden-apis
* remove generated timestamps/filenames for reproducible build
* fix CRLF line endings for windows consistency
* ability to make classes package-private
* keeping in source code control is easier on IDEs
* regeneration should be rare, no reason to be religious about generated files
* all logic already written and battle tested in lucene build
-->
<target name="regenerate" description="Regenerate antlr lexer and parser" depends="run-antlr"/>
<target name="run-antlr">
<regen-delete grammar="PlanA"/>
<regen-lexer grammar="PlanA"/>
<regen-parser grammar="PlanA"/>
<regen-fix grammar="PlanA"/>
</target>
<macrodef name="replace-value">
<attribute name="value" />
<attribute name="property" />
<attribute name="from" />
<attribute name="to" />
<sequential>
<loadresource property="@{property}">
<string value="@{value}"/>
<filterchain>
<tokenfilter>
<filetokenizer/>
<replacestring from="@{from}" to="@{to}"/>
</tokenfilter>
</filterchain>
</loadresource>
</sequential>
</macrodef>
<macrodef name="regen-delete">
<attribute name="grammar" />
<sequential>
<local name="output.path"/>
<patternset id="grammar.@{grammar}.patternset">
<include name="@{grammar}Lexer.java" />
<include name="@{grammar}Parser.java" />
<include name="@{grammar}ParserVisitor.java" />
<include name="@{grammar}ParserBaseVisitor.java" />
</patternset>
<property name="output.path" location="src/main/java/org/elasticsearch/plan/a"/>
<!-- delete parser and lexer so files will be generated -->
<delete dir="${output.path}">
<patternset refid="grammar.@{grammar}.patternset"/>
</delete>
</sequential>
</macrodef>
<macrodef name="regen-lexer">
<attribute name="grammar" />
<sequential>
<local name="grammar.path"/>
<local name="output.path"/>
<property name="grammar.path" location="src/main/antlr"/>
<property name="output.path" location="src/main/java/org/elasticsearch/plan/a"/>
<!-- invoke ANTLR4 -->
<java classname="org.antlr.v4.Tool" fork="true" failonerror="true" classpathref="regenerate.classpath" taskname="antlr">
<sysproperty key="file.encoding" value="UTF-8"/>
<sysproperty key="user.language" value="en"/>
<sysproperty key="user.country" value="US"/>
<sysproperty key="user.variant" value=""/>
<arg value="-package"/>
<arg value="org.elasticsearch.plan.a"/>
<arg value="-o"/>
<arg path="${output.path}"/>
<arg path="${grammar.path}/@{grammar}Lexer.g4"/>
</java>
</sequential>
</macrodef>
<macrodef name="regen-parser">
<attribute name="grammar" />
<sequential>
<local name="grammar.path"/>
<local name="output.path"/>
<property name="grammar.path" location="src/main/antlr"/>
<property name="output.path" location="src/main/java/org/elasticsearch/plan/a"/>
<!-- invoke ANTLR4 -->
<java classname="org.antlr.v4.Tool" fork="true" failonerror="true" classpathref="regenerate.classpath" taskname="antlr">
<sysproperty key="file.encoding" value="UTF-8"/>
<sysproperty key="user.language" value="en"/>
<sysproperty key="user.country" value="US"/>
<sysproperty key="user.variant" value=""/>
<arg value="-package"/>
<arg value="org.elasticsearch.plan.a"/>
<arg value="-no-listener"/>
<arg value="-visitor"/>
<!-- <arg value="-Xlog"/> -->
<arg value="-o"/>
<arg path="${output.path}"/>
<arg path="${grammar.path}/@{grammar}Parser.g4"/>
</java>
</sequential>
</macrodef>
<macrodef name="regen-fix">
<attribute name="grammar" />
<sequential>
<local name="grammar.path"/>
<local name="output.path"/>
<property name="grammar.path" location="src/main/antlr"/>
<property name="output.path" location="src/main/java/org/elasticsearch/plan/a"/>
<patternset id="grammar.@{grammar}.patternset">
<include name="@{grammar}Lexer.java" />
<include name="@{grammar}Parser.java" />
<include name="@{grammar}ParserVisitor.java" />
<include name="@{grammar}ParserBaseVisitor.java" />
</patternset>
<!-- fileset with files to edit -->
<fileset id="grammar.fileset" dir="${output.path}">
<patternset refid="grammar.@{grammar}.patternset"/>
</fileset>
<!-- remove files that are not needed to compile or at runtime -->
<delete dir="${grammar.path}" includes="@{grammar}*.tokens"/>
<delete dir="${output.path}" includes="@{grammar}*.tokens"/>
<!-- make the generated classes package private -->
<replaceregexp match="public ((interface|class) \Q@{grammar}\E\w+)" replace="\1" encoding="UTF-8">
<fileset refid="grammar.fileset"/>
</replaceregexp>
<!-- nuke timestamps/filenames in generated files -->
<replaceregexp match="\Q// Generated from \E.*" replace="\/\/ ANTLR GENERATED CODE: DO NOT EDIT" encoding="UTF-8">
<fileset refid="grammar.fileset"/>
</replaceregexp>
<!-- remove tabs in antlr generated files -->
<replaceregexp match="\t" flags="g" replace=" " encoding="UTF-8">
<fileset refid="grammar.fileset"/>
</replaceregexp>
<!-- fix line endings -->
<fixcrlf srcdir="${output.path}">
<patternset refid="grammar.@{grammar}.patternset"/>
</fixcrlf>
</sequential>
</macrodef>
</project>

48
plugins/lang-plan-a/build.gradle Normal file
View File

@ -0,0 +1,48 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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.
*/
import org.apache.tools.ant.types.Path
esplugin {
description 'An easy, safe and fast scripting language for Elasticsearch'
classname 'org.elasticsearch.plan.a.PlanAPlugin'
}
dependencies {
compile 'org.antlr:antlr4-runtime:4.5.1-1'
compile 'org.ow2.asm:asm:5.0.4'
compile 'org.ow2.asm:asm-commons:5.0.4'
}
compileJava.options.compilerArgs << '-Xlint:-cast,-fallthrough,-rawtypes'
compileTestJava.options.compilerArgs << '-Xlint:-unchecked'
// regeneration logic, comes in via ant right now
// don't port it to gradle, it works fine.
configurations {
regenerate
}
dependencies {
regenerate 'org.antlr:antlr4:4.5.1-1'
}
ant.references['regenerate.classpath'] = new Path(ant.project, configurations.regenerate.asPath)
ant.importBuild 'ant.xml'

1
plugins/lang-plan-a/licenses/antlr4-runtime-4.5.1-1.jar.sha1 Normal file
View File

@ -0,0 +1 @@
66144204f9d6d7d3f3f775622c2dd7e9bd511d97

26
plugins/lang-plan-a/licenses/antlr4-runtime-LICENSE.txt Normal file
View File

@ -0,0 +1,26 @@
[The "BSD license"]
Copyright (c) 2015 Terence Parr, Sam Harwell
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

0
plugins/lang-plan-a/licenses/antlr4-runtime-NOTICE.txt Normal file
View File

1
plugins/lang-plan-a/licenses/asm-5.0.4.jar.sha1 Normal file
View File

@ -0,0 +1 @@
0da08b8cce7bbf903602a25a3a163ae252435795

26
plugins/lang-plan-a/licenses/asm-LICENSE.txt Normal file
View File

@ -0,0 +1,26 @@
Copyright (c) 2012 France Télécom
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holders nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
THE POSSIBILITY OF SUCH DAMAGE.

1
plugins/lang-plan-a/licenses/asm-NOTICE.txt Normal file
View File

@ -0,0 +1 @@

1
plugins/lang-plan-a/licenses/asm-commons-5.0.4.jar.sha1 Normal file
View File

@ -0,0 +1 @@
5a556786086c23cd689a0328f8519db93821c04c

26
plugins/lang-plan-a/licenses/asm-commons-LICENSE.txt Normal file
View File

@ -0,0 +1,26 @@
Copyright (c) 2012 France Télécom
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holders nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
THE POSSIBILITY OF SUCH DAMAGE.

1
plugins/lang-plan-a/licenses/asm-commons-NOTICE.txt Normal file
View File

@ -0,0 +1 @@

120
plugins/lang-plan-a/src/main/antlr/PlanALexer.g4 Normal file
View File

@ -0,0 +1,120 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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.
*/
lexer grammar PlanALexer;
@header {
import java.util.Set;
}
@members {
private Set<String> types = null;
void setTypes(Set<String> types) {
this.types = types;
}
}
WS: [ \t\n\r]+ -> skip;
COMMENT: ( '//' .*? [\n\r] | '/*' .*? '*/' ) -> skip;
LBRACK: '{';
RBRACK: '}';
LBRACE: '[';
RBRACE: ']';
LP: '(';
RP: ')';
DOT: '.' -> mode(EXT);
COMMA: ',';
SEMICOLON: ';';
IF: 'if';
ELSE: 'else';
WHILE: 'while';
DO: 'do';
FOR: 'for';
CONTINUE: 'continue';
BREAK: 'break';
RETURN: 'return';
NEW: 'new';
TRY: 'try';
CATCH: 'catch';
THROW: 'throw';
BOOLNOT: '!';
BWNOT: '~';
MUL: '*';
DIV: '/';
REM: '%';
ADD: '+';
SUB: '-';
LSH: '<<';
RSH: '>>';
USH: '>>>';
LT: '<';
LTE: '<=';
GT: '>';
GTE: '>=';
EQ: '==';
EQR: '===';
NE: '!=';
NER: '!==';
BWAND: '&';
BWXOR: '^';
BWOR: '|';
BOOLAND: '&&';
BOOLOR: '||';
COND: '?';
COLON: ':';
INCR: '++';
DECR: '--';
ASSIGN: '=';
AADD: '+=';
ASUB: '-=';
AMUL: '*=';
ADIV: '/=';
AREM: '%=';
AAND: '&=';
AXOR: '^=';
AOR: '|=';
ALSH: '<<=';
ARSH: '>>=';
AUSH: '>>>=';
ACAT: '..=';
OCTAL: '0' [0-7]+ [lL]?;
HEX: '0' [xX] [0-9a-fA-F]+ [lL]?;
INTEGER: ( '0' | [1-9] [0-9]* ) [lLfFdD]?;
DECIMAL: ( '0' | [1-9] [0-9]* ) DOT [0-9]* ( [eE] [+\-]? [0-9]+ )? [fF]?;
STRING: '"' ( '\\"' | '\\\\' | ~[\\"] )*? '"' {setText(getText().substring(1, getText().length() - 1));};
CHAR: '\'' . '\'' {setText(getText().substring(1, getText().length() - 1));};
TRUE: 'true';
FALSE: 'false';
NULL: 'null';
TYPE: ID GENERIC? {types.contains(getText().replace(" ", ""))}? {setText(getText().replace(" ", ""));};
fragment GENERIC: ' '* '<' ' '* ( ID GENERIC? ) ' '* ( COMMA ' '* ( ID GENERIC? ) ' '* )* '>';
ID: [_a-zA-Z] [_a-zA-Z0-9]*;
mode EXT;
EXTINTEGER: ( '0' | [1-9] [0-9]* ) -> mode(DEFAULT_MODE);
EXTID: [_a-zA-Z] [_a-zA-Z0-9]* -> mode(DEFAULT_MODE);

127
plugins/lang-plan-a/src/main/antlr/PlanAParser.g4 Normal file
View File

@ -0,0 +1,127 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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.
*/
parser grammar PlanAParser;
options { tokenVocab=PlanALexer; }
source
: statement+ EOF
;
statement
: IF LP expression RP block ( ELSE block )? # if
| WHILE LP expression RP ( block | empty ) # while
| DO block WHILE LP expression RP SEMICOLON? # do
| FOR LP initializer? SEMICOLON expression? SEMICOLON afterthought? RP ( block | empty ) # for
| declaration SEMICOLON? # decl
| CONTINUE SEMICOLON? # continue
| BREAK SEMICOLON? # break
| RETURN expression SEMICOLON? # return
| TRY block ( CATCH LP ( TYPE ID ) RP block )+ # try
| THROW expression SEMICOLON? # throw
| expression SEMICOLON? # expr
;
block
: LBRACK statement* RBRACK # multiple
| statement # single
;
empty
: SEMICOLON
;
initializer
: declaration
| expression
;
afterthought
: expression
;
declaration
: decltype declvar ( COMMA declvar )*
;
decltype
: TYPE (LBRACE RBRACE)*
;
declvar
: ID ( ASSIGN expression )?
;
expression
: LP expression RP # precedence
| ( OCTAL | HEX | INTEGER | DECIMAL ) # numeric
| CHAR # char
| TRUE # true
| FALSE # false
| NULL # null
| <assoc=right> extstart increment # postinc
| <assoc=right> increment extstart # preinc
| extstart # external
| <assoc=right> ( BOOLNOT | BWNOT | ADD | SUB ) expression # unary
| <assoc=right> LP decltype RP expression # cast
| expression ( MUL | DIV | REM ) expression # binary
| expression ( ADD | SUB ) expression # binary
| expression ( LSH | RSH | USH ) expression # binary
| expression ( LT | LTE | GT | GTE ) expression # comp
| expression ( EQ | EQR | NE | NER ) expression # comp
| expression BWAND expression # binary
| expression BWXOR expression # binary
| expression BWOR expression # binary
| expression BOOLAND expression # bool
| expression BOOLOR expression # bool
| <assoc=right> expression COND expression COLON expression # conditional
| <assoc=right> extstart ( ASSIGN | AADD | ASUB | AMUL | ADIV
| AREM | AAND | AXOR | AOR
| ALSH | ARSH | AUSH ) expression # assignment
;
extstart
: extprec
| extcast
| exttype
| extvar
| extnew
| extstring
;
extprec: LP ( extprec | extcast | exttype | extvar | extnew | extstring ) RP ( extdot | extbrace )?;
extcast: LP decltype RP ( extprec | extcast | exttype | extvar | extnew | extstring );
extbrace: LBRACE expression RBRACE ( extdot | extbrace )?;
extdot: DOT ( extcall | extfield );
exttype: TYPE extdot;
extcall: EXTID arguments ( extdot | extbrace )?;
extvar: ID ( extdot | extbrace )?;
extfield: ( EXTID | EXTINTEGER ) ( extdot | extbrace )?;
extnew: NEW TYPE ( ( arguments ( extdot | extbrace)? ) | ( ( LBRACE expression RBRACE )+ extdot? ) );
extstring: STRING (extdot | extbrace )?;
arguments
: ( LP ( expression ( COMMA expression )* )? RP )
;
increment
: INCR
| DECR
;

276
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/Adapter.java Normal file
View File

@ -0,0 +1,276 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import java.util.HashMap;
import java.util.Map;
import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.tree.ParseTree;
import static org.elasticsearch.plan.a.Definition.*;
import static org.elasticsearch.plan.a.PlanAParser.*;
class Adapter {
static class StatementMetadata {
final ParserRuleContext source;
boolean last;
boolean allExit;
boolean allReturn;
boolean anyReturn;
boolean allBreak;
boolean anyBreak;
boolean allContinue;
boolean anyContinue;
private StatementMetadata(final ParserRuleContext source) {
this.source = source;
last = false;
allExit = false;
allReturn = false;
anyReturn = false;
allBreak = false;
anyBreak = false;
allContinue = false;
anyContinue = false;
}
}
static class ExpressionMetadata {
final ParserRuleContext source;
boolean read;
boolean statement;
Object preConst;
Object postConst;
boolean isNull;
Type to;
Type from;
boolean explicit;
boolean typesafe;
Cast cast;
private ExpressionMetadata(final ParserRuleContext source) {
this.source = source;
read = true;
statement = false;
preConst = null;
postConst = null;
isNull = false;
to = null;
from = null;
explicit = false;
typesafe = true;
cast = null;
}
}
static class ExternalMetadata {
final ParserRuleContext source;
boolean read;
ParserRuleContext storeExpr;
int token;
boolean pre;
boolean post;
int scope;
Type current;
boolean statik;
boolean statement;
Object constant;
private ExternalMetadata(final ParserRuleContext source) {
this.source = source;
read = false;
storeExpr = null;
token = 0;
pre = false;
post = false;
scope = 0;
current = null;
statik = false;
statement = false;
constant = null;
}
}
static class ExtNodeMetadata {
final ParserRuleContext parent;
final ParserRuleContext source;
Object target;
boolean last;
Type type;
Type promote;
Cast castFrom;
Cast castTo;
private ExtNodeMetadata(final ParserRuleContext parent, final ParserRuleContext source) {
this.parent = parent;
this.source = source;
target = null;
last = false;
type = null;
promote = null;
castFrom = null;
castTo = null;
}
}
static String error(final ParserRuleContext ctx) {
return "Error [" + ctx.getStart().getLine() + ":" + ctx.getStart().getCharPositionInLine() + "]: ";
}
final Definition definition;
final String source;
final ParserRuleContext root;
final CompilerSettings settings;
private final Map<ParserRuleContext, StatementMetadata> statementMetadata;
private final Map<ParserRuleContext, ExpressionMetadata> expressionMetadata;
private final Map<ParserRuleContext, ExternalMetadata> externalMetadata;
private final Map<ParserRuleContext, ExtNodeMetadata> extNodeMetadata;
Adapter(final Definition definition, final String source, final ParserRuleContext root, final CompilerSettings settings) {
this.definition = definition;
this.source = source;
this.root = root;
this.settings = settings;
statementMetadata = new HashMap<>();
expressionMetadata = new HashMap<>();
externalMetadata = new HashMap<>();
extNodeMetadata = new HashMap<>();
}
StatementMetadata createStatementMetadata(final ParserRuleContext source) {
final StatementMetadata sourcesmd = new StatementMetadata(source);
statementMetadata.put(source, sourcesmd);
return sourcesmd;
}
StatementMetadata getStatementMetadata(final ParserRuleContext source) {
final StatementMetadata sourcesmd = statementMetadata.get(source);
if (sourcesmd == null) {
throw new IllegalStateException(error(source) + "Statement metadata does not exist at" +
" the parse node with text [" + source.getText() + "].");
}
return sourcesmd;
}
ExpressionContext updateExpressionTree(ExpressionContext source) {
if (source instanceof PrecedenceContext) {
final ParserRuleContext parent = source.getParent();
int index = 0;
for (final ParseTree child : parent.children) {
if (child == source) {
break;
}
++index;
}
while (source instanceof PrecedenceContext) {
source = ((PrecedenceContext)source).expression();
}
parent.children.set(index, source);
}
return source;
}
ExpressionMetadata createExpressionMetadata(ParserRuleContext source) {
final ExpressionMetadata sourceemd = new ExpressionMetadata(source);
expressionMetadata.put(source, sourceemd);
return sourceemd;
}
ExpressionMetadata getExpressionMetadata(final ParserRuleContext source) {
final ExpressionMetadata sourceemd = expressionMetadata.get(source);
if (sourceemd == null) {
throw new IllegalStateException(error(source) + "Expression metadata does not exist at" +
" the parse node with text [" + source.getText() + "].");
}
return sourceemd;
}
ExternalMetadata createExternalMetadata(final ParserRuleContext source) {
final ExternalMetadata sourceemd = new ExternalMetadata(source);
externalMetadata.put(source, sourceemd);
return sourceemd;
}
ExternalMetadata getExternalMetadata(final ParserRuleContext source) {
final ExternalMetadata sourceemd = externalMetadata.get(source);
if (sourceemd == null) {
throw new IllegalStateException(error(source) + "External metadata does not exist at" +
" the parse node with text [" + source.getText() + "].");
}
return sourceemd;
}
ExtNodeMetadata createExtNodeMetadata(final ParserRuleContext parent, final ParserRuleContext source) {
final ExtNodeMetadata sourceemd = new ExtNodeMetadata(parent, source);
extNodeMetadata.put(source, sourceemd);
return sourceemd;
}
ExtNodeMetadata getExtNodeMetadata(final ParserRuleContext source) {
final ExtNodeMetadata sourceemd = extNodeMetadata.get(source);
if (sourceemd == null) {
throw new IllegalStateException(error(source) + "External metadata does not exist at" +
" the parse node with text [" + source.getText() + "].");
}
return sourceemd;
}
}

2983
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/Analyzer.java Normal file
View File

File diff suppressed because it is too large Load Diff

154
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/Compiler.java Normal file
View File

@ -0,0 +1,154 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.CodeSource;
import java.security.SecureClassLoader;
import java.security.cert.Certificate;
import org.antlr.v4.runtime.ANTLRInputStream;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.ParserRuleContext;
import org.elasticsearch.bootstrap.BootstrapInfo;
final class Compiler {
private static Definition DEFAULT_DEFINITION = new Definition(new Definition());
/** we define the class with lowest privileges */
private static final CodeSource CODESOURCE;
static {
try {
CODESOURCE = new CodeSource(new URL("file:" + BootstrapInfo.UNTRUSTED_CODEBASE), (Certificate[]) null);
} catch (MalformedURLException impossible) {
throw new RuntimeException(impossible);
}
}
static class Loader extends SecureClassLoader {
Loader(ClassLoader parent) {
super(parent);
}
Class<? extends Executable> define(String name, byte[] bytes) {
return defineClass(name, bytes, 0, bytes.length, CODESOURCE).asSubclass(Executable.class);
}
}
static Executable compile(Loader loader, final String name, final String source, final Definition custom, CompilerSettings settings) {
long start = System.currentTimeMillis();
final Definition definition = custom == null ? DEFAULT_DEFINITION : new Definition(custom);
//long end = System.currentTimeMillis() - start;
//System.out.println("types: " + end);
//start = System.currentTimeMillis();
//final ParserRuleContext root = createParseTree(source, types);
final ANTLRInputStream stream = new ANTLRInputStream(source);
final ErrorHandlingLexer lexer = new ErrorHandlingLexer(stream);
final PlanAParser parser = new PlanAParser(new CommonTokenStream(lexer));
final ParserErrorStrategy strategy = new ParserErrorStrategy();
lexer.removeErrorListeners();
lexer.setTypes(definition.structs.keySet());
//List<? extends Token> tokens = lexer.getAllTokens();
//for (final Token token : tokens) {
// System.out.println(token.getType() + " " + token.getText());
//}
parser.removeErrorListeners();
parser.setErrorHandler(strategy);
ParserRuleContext root = parser.source();
//end = System.currentTimeMillis() - start;
//System.out.println("tree: " + end);
final Adapter adapter = new Adapter(definition, source, root, settings);
start = System.currentTimeMillis();
Analyzer.analyze(adapter);
//System.out.println(root.toStringTree(parser));
//end = System.currentTimeMillis() - start;
//System.out.println("analyze: " + end);
//start = System.currentTimeMillis();
final byte[] bytes = Writer.write(adapter);
//end = System.currentTimeMillis() - start;
//System.out.println("write: " + end);
//start = System.currentTimeMillis();
final Executable executable = createExecutable(loader, definition, name, source, bytes);
//end = System.currentTimeMillis() - start;
//System.out.println("create: " + end);
return executable;
}
private static ParserRuleContext createParseTree(String source, Definition definition) {
final ANTLRInputStream stream = new ANTLRInputStream(source);
final ErrorHandlingLexer lexer = new ErrorHandlingLexer(stream);
final PlanAParser parser = new PlanAParser(new CommonTokenStream(lexer));
final ParserErrorStrategy strategy = new ParserErrorStrategy();
lexer.removeErrorListeners();
lexer.setTypes(definition.structs.keySet());
parser.removeErrorListeners();
parser.setErrorHandler(strategy);
ParserRuleContext root = parser.source();
// System.out.println(root.toStringTree(parser));
return root;
}
private static Executable createExecutable(Loader loader, Definition definition, String name, String source, byte[] bytes) {
try {
// for debugging:
//try {
// FileOutputStream f = new FileOutputStream(new File("/Users/jdconrad/lang/generated/out.class"), false);
// f.write(bytes);
// f.close();
//} catch (Exception e) {
// throw new RuntimeException(e);
//}
final Class<? extends Executable> clazz = loader.define(Writer.CLASS_NAME, bytes);
final java.lang.reflect.Constructor<? extends Executable> constructor =
clazz.getConstructor(Definition.class, String.class, String.class);
return constructor.newInstance(definition, name, source);
} catch (Exception exception) {
throw new IllegalStateException(
"An internal error occurred attempting to define the script [" + name + "].", exception);
}
}
private Compiler() {}
}

49
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/CompilerSettings.java Normal file
View File

@ -0,0 +1,49 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
/**
* Settings to use when compiling a script
*/
final class CompilerSettings {
private boolean numericOverflow = true;
/**
* Returns {@code true} if numeric operations should overflow, {@code false}
* if they should signal an exception.
* <p>
* If this value is {@code true} (default), then things behave like java:
* overflow for integer types can result in unexpected values / unexpected
* signs, and overflow for floating point types can result in infinite or
* {@code NaN} values.
*/
public boolean getNumericOverflow() {
return numericOverflow;
}
/**
* Set {@code true} for numerics to overflow, false to deliver exceptions.
* @see #getNumericOverflow
*/
public void setNumericOverflow(boolean allow) {
this.numericOverflow = allow;
}
}

1250
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/Def.java Normal file
View File

File diff suppressed because it is too large Load Diff

1809
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/Definition.java Normal file
View File

File diff suppressed because it is too large Load Diff

45
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/ErrorHandlingLexer.java Normal file
View File

@ -0,0 +1,45 @@
package org.elasticsearch.plan.a;
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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.
*/
import java.text.ParseException;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.LexerNoViableAltException;
import org.antlr.v4.runtime.misc.Interval;
class ErrorHandlingLexer extends PlanALexer {
public ErrorHandlingLexer(CharStream charStream) {
super(charStream);
}
@Override
public void recover(LexerNoViableAltException lnvae) {
CharStream charStream = lnvae.getInputStream();
int startIndex = lnvae.getStartIndex();
String text = charStream.getText(Interval.of(startIndex, charStream.index()));
ParseException parseException = new ParseException("Error [" + _tokenStartLine + ":" +
_tokenStartCharPositionInLine + "]: unexpected character [" +
getErrorDisplay(text) + "].", _tokenStartCharIndex);
parseException.initCause(lnvae);
throw new RuntimeException(parseException);
}
}

50
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/Executable.java Normal file
View File

@ -0,0 +1,50 @@
package org.elasticsearch.plan.a;
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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.
*/
import java.util.Map;
public abstract class Executable {
protected final Definition definition;
private final String name;
private final String source;
public Executable(final Definition definition, final String name, final String source) {
this.definition = definition;
this.name = name;
this.source = source;
}
public String getName() {
return name;
}
public String getSource() {
return source;
}
public Definition getDefinition() {
return definition;
}
public abstract Object execute(Map<String, Object> input);
}

74
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/ParserErrorStrategy.java Normal file
View File

@ -0,0 +1,74 @@
package org.elasticsearch.plan.a;
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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.
*/
import java.text.ParseException;
import org.antlr.v4.runtime.DefaultErrorStrategy;
import org.antlr.v4.runtime.InputMismatchException;
import org.antlr.v4.runtime.NoViableAltException;
import org.antlr.v4.runtime.Parser;
import org.antlr.v4.runtime.RecognitionException;
import org.antlr.v4.runtime.Token;
class ParserErrorStrategy extends DefaultErrorStrategy {
@Override
public void recover(Parser recognizer, RecognitionException re) {
Token token = re.getOffendingToken();
String message;
if (token == null) {
message = "Error: no parse token found.";
} else if (re instanceof InputMismatchException) {
message = "Error[" + token.getLine() + ":" + token.getCharPositionInLine() + "]:" +
" unexpected token [" + getTokenErrorDisplay(token) + "]" +
" was expecting one of [" + re.getExpectedTokens().toString(recognizer.getVocabulary()) + "].";
} else if (re instanceof NoViableAltException) {
if (token.getType() == PlanAParser.EOF) {
message = "Error: unexpected end of script.";
} else {
message = "Error[" + token.getLine() + ":" + token.getCharPositionInLine() + "]:" +
"invalid sequence of tokens near [" + getTokenErrorDisplay(token) + "].";
}
} else {
message = "Error[" + token.getLine() + ":" + token.getCharPositionInLine() + "]:" +
" unexpected token near [" + getTokenErrorDisplay(token) + "].";
}
ParseException parseException = new ParseException(message, token == null ? -1 : token.getStartIndex());
parseException.initCause(re);
throw new RuntimeException(parseException);
}
@Override
public Token recoverInline(Parser recognizer) throws RecognitionException {
Token token = recognizer.getCurrentToken();
String message = "Error[" + token.getLine() + ":" + token.getCharPositionInLine() + "]:" +
" unexpected token [" + getTokenErrorDisplay(token) + "]" +
" was expecting one of [" + recognizer.getExpectedTokens().toString(recognizer.getVocabulary()) + "].";
ParseException parseException = new ParseException(message, token.getStartIndex());
throw new RuntimeException(parseException);
}
@Override
public void sync(Parser recognizer) {
}
}

390
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/PlanALexer.java Normal file
View File

@ -0,0 +1,390 @@
// ANTLR GENERATED CODE: DO NOT EDIT
package org.elasticsearch.plan.a;
import java.util.Set;
import org.antlr.v4.runtime.Lexer;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.TokenStream;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.misc.*;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
class PlanALexer extends Lexer {
static { RuntimeMetaData.checkVersion("4.5.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
WS=1, COMMENT=2, LBRACK=3, RBRACK=4, LBRACE=5, RBRACE=6, LP=7, RP=8, DOT=9,
COMMA=10, SEMICOLON=11, IF=12, ELSE=13, WHILE=14, DO=15, FOR=16, CONTINUE=17,
BREAK=18, RETURN=19, NEW=20, TRY=21, CATCH=22, THROW=23, BOOLNOT=24, BWNOT=25,
MUL=26, DIV=27, REM=28, ADD=29, SUB=30, LSH=31, RSH=32, USH=33, LT=34,
LTE=35, GT=36, GTE=37, EQ=38, EQR=39, NE=40, NER=41, BWAND=42, BWXOR=43,
BWOR=44, BOOLAND=45, BOOLOR=46, COND=47, COLON=48, INCR=49, DECR=50, ASSIGN=51,
AADD=52, ASUB=53, AMUL=54, ADIV=55, AREM=56, AAND=57, AXOR=58, AOR=59,
ALSH=60, ARSH=61, AUSH=62, ACAT=63, OCTAL=64, HEX=65, INTEGER=66, DECIMAL=67,
STRING=68, CHAR=69, TRUE=70, FALSE=71, NULL=72, TYPE=73, ID=74, EXTINTEGER=75,
EXTID=76;
public static final int EXT = 1;
public static String[] modeNames = {
"DEFAULT_MODE", "EXT"
};
public static final String[] ruleNames = {
"WS", "COMMENT", "LBRACK", "RBRACK", "LBRACE", "RBRACE", "LP", "RP", "DOT",
"COMMA", "SEMICOLON", "IF", "ELSE", "WHILE", "DO", "FOR", "CONTINUE",
"BREAK", "RETURN", "NEW", "TRY", "CATCH", "THROW", "BOOLNOT", "BWNOT",
"MUL", "DIV", "REM", "ADD", "SUB", "LSH", "RSH", "USH", "LT", "LTE", "GT",
"GTE", "EQ", "EQR", "NE", "NER", "BWAND", "BWXOR", "BWOR", "BOOLAND",
"BOOLOR", "COND", "COLON", "INCR", "DECR", "ASSIGN", "AADD", "ASUB", "AMUL",
"ADIV", "AREM", "AAND", "AXOR", "AOR", "ALSH", "ARSH", "AUSH", "ACAT",
"OCTAL", "HEX", "INTEGER", "DECIMAL", "STRING", "CHAR", "TRUE", "FALSE",
"NULL", "TYPE", "GENERIC", "ID", "EXTINTEGER", "EXTID"
};
private static final String[] _LITERAL_NAMES = {
null, null, null, "'{'", "'}'", "'['", "']'", "'('", "')'", "'.'", "','",
"';'", "'if'", "'else'", "'while'", "'do'", "'for'", "'continue'", "'break'",
"'return'", "'new'", "'try'", "'catch'", "'throw'", "'!'", "'~'", "'*'",
"'/'", "'%'", "'+'", "'-'", "'<<'", "'>>'", "'>>>'", "'<'", "'<='", "'>'",
"'>='", "'=='", "'==='", "'!='", "'!=='", "'&'", "'^'", "'|'", "'&&'",
"'||'", "'?'", "':'", "'++'", "'--'", "'='", "'+='", "'-='", "'*='", "'/='",
"'%='", "'&='", "'^='", "'|='", "'<<='", "'>>='", "'>>>='", "'..='", null,
null, null, null, null, null, "'true'", "'false'", "'null'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, "WS", "COMMENT", "LBRACK", "RBRACK", "LBRACE", "RBRACE", "LP", "RP",
"DOT", "COMMA", "SEMICOLON", "IF", "ELSE", "WHILE", "DO", "FOR", "CONTINUE",
"BREAK", "RETURN", "NEW", "TRY", "CATCH", "THROW", "BOOLNOT", "BWNOT",
"MUL", "DIV", "REM", "ADD", "SUB", "LSH", "RSH", "USH", "LT", "LTE", "GT",
"GTE", "EQ", "EQR", "NE", "NER", "BWAND", "BWXOR", "BWOR", "BOOLAND",
"BOOLOR", "COND", "COLON", "INCR", "DECR", "ASSIGN", "AADD", "ASUB", "AMUL",
"ADIV", "AREM", "AAND", "AXOR", "AOR", "ALSH", "ARSH", "AUSH", "ACAT",
"OCTAL", "HEX", "INTEGER", "DECIMAL", "STRING", "CHAR", "TRUE", "FALSE",
"NULL", "TYPE", "ID", "EXTINTEGER", "EXTID"
};
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "<INVALID>";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
private Set<String> types = null;
void setTypes(Set<String> types) {
this.types = types;
}
public PlanALexer(CharStream input) {
super(input);
_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@Override
public String getGrammarFileName() { return "PlanALexer.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public String[] getModeNames() { return modeNames; }
@Override
public ATN getATN() { return _ATN; }
@Override
public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
switch (ruleIndex) {
case 67:
STRING_action((RuleContext)_localctx, actionIndex);
break;
case 68:
CHAR_action((RuleContext)_localctx, actionIndex);
break;
case 72:
TYPE_action((RuleContext)_localctx, actionIndex);
break;
}
}
private void STRING_action(RuleContext _localctx, int actionIndex) {
switch (actionIndex) {
case 0:
setText(getText().substring(1, getText().length() - 1));
break;
}
}
private void CHAR_action(RuleContext _localctx, int actionIndex) {
switch (actionIndex) {
case 1:
setText(getText().substring(1, getText().length() - 1));
break;
}
}
private void TYPE_action(RuleContext _localctx, int actionIndex) {
switch (actionIndex) {
case 2:
setText(getText().replace(" ", ""));
break;
}
}
@Override
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 72:
return TYPE_sempred((RuleContext)_localctx, predIndex);
}
return true;
}
private boolean TYPE_sempred(RuleContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return types.contains(getText().replace(" ", ""));
}
return true;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2N\u0236\b\1\b\1\4"+
"\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n"+
"\4\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22"+
"\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31"+
"\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t"+
" \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t"+
"+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64"+
"\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t"+
"=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4"+
"I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\3\2\6\2\u00a0\n\2\r\2\16\2\u00a1\3"+
"\2\3\2\3\3\3\3\3\3\3\3\7\3\u00aa\n\3\f\3\16\3\u00ad\13\3\3\3\3\3\3\3\3"+
"\3\3\3\7\3\u00b4\n\3\f\3\16\3\u00b7\13\3\3\3\3\3\5\3\u00bb\n\3\3\3\3\3"+
"\3\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\n\3\n\3\13"+
"\3\13\3\f\3\f\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\17\3\17\3\17\3\17"+
"\3\17\3\17\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22"+
"\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\24\3\24\3\24\3\24"+
"\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\27\3\27\3\27"+
"\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\32\3\32\3\33"+
"\3\33\3\34\3\34\3\35\3\35\3\36\3\36\3\37\3\37\3 \3 \3 \3!\3!\3!\3\"\3"+
"\"\3\"\3\"\3#\3#\3$\3$\3$\3%\3%\3&\3&\3&\3\'\3\'\3\'\3(\3(\3(\3(\3)\3"+
")\3)\3*\3*\3*\3*\3+\3+\3,\3,\3-\3-\3.\3.\3.\3/\3/\3/\3\60\3\60\3\61\3"+
"\61\3\62\3\62\3\62\3\63\3\63\3\63\3\64\3\64\3\65\3\65\3\65\3\66\3\66\3"+
"\66\3\67\3\67\3\67\38\38\38\39\39\39\3:\3:\3:\3;\3;\3;\3<\3<\3<\3=\3="+
"\3=\3=\3>\3>\3>\3>\3?\3?\3?\3?\3?\3@\3@\3@\3@\3A\3A\6A\u0185\nA\rA\16"+
"A\u0186\3A\5A\u018a\nA\3B\3B\3B\6B\u018f\nB\rB\16B\u0190\3B\5B\u0194\n"+
"B\3C\3C\3C\7C\u0199\nC\fC\16C\u019c\13C\5C\u019e\nC\3C\5C\u01a1\nC\3D"+
"\3D\3D\7D\u01a6\nD\fD\16D\u01a9\13D\5D\u01ab\nD\3D\3D\7D\u01af\nD\fD\16"+
"D\u01b2\13D\3D\3D\5D\u01b6\nD\3D\6D\u01b9\nD\rD\16D\u01ba\5D\u01bd\nD"+
"\3D\5D\u01c0\nD\3E\3E\3E\3E\3E\3E\7E\u01c8\nE\fE\16E\u01cb\13E\3E\3E\3"+
"E\3F\3F\3F\3F\3F\3G\3G\3G\3G\3G\3H\3H\3H\3H\3H\3H\3I\3I\3I\3I\3I\3J\3"+
"J\5J\u01e7\nJ\3J\3J\3J\3K\7K\u01ed\nK\fK\16K\u01f0\13K\3K\3K\7K\u01f4"+
"\nK\fK\16K\u01f7\13K\3K\3K\5K\u01fb\nK\3K\7K\u01fe\nK\fK\16K\u0201\13"+
"K\3K\3K\7K\u0205\nK\fK\16K\u0208\13K\3K\3K\5K\u020c\nK\3K\7K\u020f\nK"+
"\fK\16K\u0212\13K\7K\u0214\nK\fK\16K\u0217\13K\3K\3K\3L\3L\7L\u021d\n"+
"L\fL\16L\u0220\13L\3M\3M\3M\7M\u0225\nM\fM\16M\u0228\13M\5M\u022a\nM\3"+
"M\3M\3N\3N\7N\u0230\nN\fN\16N\u0233\13N\3N\3N\5\u00ab\u00b5\u01c9\2O\4"+
"\3\6\4\b\5\n\6\f\7\16\b\20\t\22\n\24\13\26\f\30\r\32\16\34\17\36\20 \21"+
"\"\22$\23&\24(\25*\26,\27.\30\60\31\62\32\64\33\66\348\35:\36<\37> @!"+
"B\"D#F$H%J&L\'N(P)R*T+V,X-Z.\\/^\60`\61b\62d\63f\64h\65j\66l\67n8p9r:"+
"t;v<x=z>|?~@\u0080A\u0082B\u0084C\u0086D\u0088E\u008aF\u008cG\u008eH\u0090"+
"I\u0092J\u0094K\u0096\2\u0098L\u009aM\u009cN\4\2\3\21\5\2\13\f\17\17\""+
"\"\4\2\f\f\17\17\3\2\629\4\2NNnn\4\2ZZzz\5\2\62;CHch\3\2\63;\3\2\62;\b"+
"\2FFHHNNffhhnn\4\2GGgg\4\2--//\4\2HHhh\4\2$$^^\5\2C\\aac|\6\2\62;C\\a"+
"ac|\u0255\2\4\3\2\2\2\2\6\3\2\2\2\2\b\3\2\2\2\2\n\3\2\2\2\2\f\3\2\2\2"+
"\2\16\3\2\2\2\2\20\3\2\2\2\2\22\3\2\2\2\2\24\3\2\2\2\2\26\3\2\2\2\2\30"+
"\3\2\2\2\2\32\3\2\2\2\2\34\3\2\2\2\2\36\3\2\2\2\2 \3\2\2\2\2\"\3\2\2\2"+
"\2$\3\2\2\2\2&\3\2\2\2\2(\3\2\2\2\2*\3\2\2\2\2,\3\2\2\2\2.\3\2\2\2\2\60"+
"\3\2\2\2\2\62\3\2\2\2\2\64\3\2\2\2\2\66\3\2\2\2\28\3\2\2\2\2:\3\2\2\2"+
"\2<\3\2\2\2\2>\3\2\2\2\2@\3\2\2\2\2B\3\2\2\2\2D\3\2\2\2\2F\3\2\2\2\2H"+
"\3\2\2\2\2J\3\2\2\2\2L\3\2\2\2\2N\3\2\2\2\2P\3\2\2\2\2R\3\2\2\2\2T\3\2"+
"\2\2\2V\3\2\2\2\2X\3\2\2\2\2Z\3\2\2\2\2\\\3\2\2\2\2^\3\2\2\2\2`\3\2\2"+
"\2\2b\3\2\2\2\2d\3\2\2\2\2f\3\2\2\2\2h\3\2\2\2\2j\3\2\2\2\2l\3\2\2\2\2"+
"n\3\2\2\2\2p\3\2\2\2\2r\3\2\2\2\2t\3\2\2\2\2v\3\2\2\2\2x\3\2\2\2\2z\3"+
"\2\2\2\2|\3\2\2\2\2~\3\2\2\2\2\u0080\3\2\2\2\2\u0082\3\2\2\2\2\u0084\3"+
"\2\2\2\2\u0086\3\2\2\2\2\u0088\3\2\2\2\2\u008a\3\2\2\2\2\u008c\3\2\2\2"+
"\2\u008e\3\2\2\2\2\u0090\3\2\2\2\2\u0092\3\2\2\2\2\u0094\3\2\2\2\2\u0098"+
"\3\2\2\2\3\u009a\3\2\2\2\3\u009c\3\2\2\2\4\u009f\3\2\2\2\6\u00ba\3\2\2"+
"\2\b\u00be\3\2\2\2\n\u00c0\3\2\2\2\f\u00c2\3\2\2\2\16\u00c4\3\2\2\2\20"+
"\u00c6\3\2\2\2\22\u00c8\3\2\2\2\24\u00ca\3\2\2\2\26\u00ce\3\2\2\2\30\u00d0"+
"\3\2\2\2\32\u00d2\3\2\2\2\34\u00d5\3\2\2\2\36\u00da\3\2\2\2 \u00e0\3\2"+
"\2\2\"\u00e3\3\2\2\2$\u00e7\3\2\2\2&\u00f0\3\2\2\2(\u00f6\3\2\2\2*\u00fd"+
"\3\2\2\2,\u0101\3\2\2\2.\u0105\3\2\2\2\60\u010b\3\2\2\2\62\u0111\3\2\2"+
"\2\64\u0113\3\2\2\2\66\u0115\3\2\2\28\u0117\3\2\2\2:\u0119\3\2\2\2<\u011b"+
"\3\2\2\2>\u011d\3\2\2\2@\u011f\3\2\2\2B\u0122\3\2\2\2D\u0125\3\2\2\2F"+
"\u0129\3\2\2\2H\u012b\3\2\2\2J\u012e\3\2\2\2L\u0130\3\2\2\2N\u0133\3\2"+
"\2\2P\u0136\3\2\2\2R\u013a\3\2\2\2T\u013d\3\2\2\2V\u0141\3\2\2\2X\u0143"+
"\3\2\2\2Z\u0145\3\2\2\2\\\u0147\3\2\2\2^\u014a\3\2\2\2`\u014d\3\2\2\2"+
"b\u014f\3\2\2\2d\u0151\3\2\2\2f\u0154\3\2\2\2h\u0157\3\2\2\2j\u0159\3"+
"\2\2\2l\u015c\3\2\2\2n\u015f\3\2\2\2p\u0162\3\2\2\2r\u0165\3\2\2\2t\u0168"+
"\3\2\2\2v\u016b\3\2\2\2x\u016e\3\2\2\2z\u0171\3\2\2\2|\u0175\3\2\2\2~"+
"\u0179\3\2\2\2\u0080\u017e\3\2\2\2\u0082\u0182\3\2\2\2\u0084\u018b\3\2"+
"\2\2\u0086\u019d\3\2\2\2\u0088\u01aa\3\2\2\2\u008a\u01c1\3\2\2\2\u008c"+
"\u01cf\3\2\2\2\u008e\u01d4\3\2\2\2\u0090\u01d9\3\2\2\2\u0092\u01df\3\2"+
"\2\2\u0094\u01e4\3\2\2\2\u0096\u01ee\3\2\2\2\u0098\u021a\3\2\2\2\u009a"+
"\u0229\3\2\2\2\u009c\u022d\3\2\2\2\u009e\u00a0\t\2\2\2\u009f\u009e\3\2"+
"\2\2\u00a0\u00a1\3\2\2\2\u00a1\u009f\3\2\2\2\u00a1\u00a2\3\2\2\2\u00a2"+
"\u00a3\3\2\2\2\u00a3\u00a4\b\2\2\2\u00a4\5\3\2\2\2\u00a5\u00a6\7\61\2"+
"\2\u00a6\u00a7\7\61\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\13\2\2\2\u00a9"+
"\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00ac\3\2\2\2\u00ab\u00a9\3\2"+
"\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00bb\t\3\2\2\u00af"+
"\u00b0\7\61\2\2\u00b0\u00b1\7,\2\2\u00b1\u00b5\3\2\2\2\u00b2\u00b4\13"+
"\2\2\2\u00b3\u00b2\3\2\2\2\u00b4\u00b7\3\2\2\2\u00b5\u00b6\3\2\2\2\u00b5"+
"\u00b3\3\2\2\2\u00b6\u00b8\3\2\2\2\u00b7\u00b5\3\2\2\2\u00b8\u00b9\7,"+
"\2\2\u00b9\u00bb\7\61\2\2\u00ba\u00a5\3\2\2\2\u00ba\u00af\3\2\2\2\u00bb"+
"\u00bc\3\2\2\2\u00bc\u00bd\b\3\2\2\u00bd\7\3\2\2\2\u00be\u00bf\7}\2\2"+
"\u00bf\t\3\2\2\2\u00c0\u00c1\7\177\2\2\u00c1\13\3\2\2\2\u00c2\u00c3\7"+
"]\2\2\u00c3\r\3\2\2\2\u00c4\u00c5\7_\2\2\u00c5\17\3\2\2\2\u00c6\u00c7"+
"\7*\2\2\u00c7\21\3\2\2\2\u00c8\u00c9\7+\2\2\u00c9\23\3\2\2\2\u00ca\u00cb"+
"\7\60\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00cd\b\n\3\2\u00cd\25\3\2\2\2\u00ce"+
"\u00cf\7.\2\2\u00cf\27\3\2\2\2\u00d0\u00d1\7=\2\2\u00d1\31\3\2\2\2\u00d2"+
"\u00d3\7k\2\2\u00d3\u00d4\7h\2\2\u00d4\33\3\2\2\2\u00d5\u00d6\7g\2\2\u00d6"+
"\u00d7\7n\2\2\u00d7\u00d8\7u\2\2\u00d8\u00d9\7g\2\2\u00d9\35\3\2\2\2\u00da"+
"\u00db\7y\2\2\u00db\u00dc\7j\2\2\u00dc\u00dd\7k\2\2\u00dd\u00de\7n\2\2"+
"\u00de\u00df\7g\2\2\u00df\37\3\2\2\2\u00e0\u00e1\7f\2\2\u00e1\u00e2\7"+
"q\2\2\u00e2!\3\2\2\2\u00e3\u00e4\7h\2\2\u00e4\u00e5\7q\2\2\u00e5\u00e6"+
"\7t\2\2\u00e6#\3\2\2\2\u00e7\u00e8\7e\2\2\u00e8\u00e9\7q\2\2\u00e9\u00ea"+
"\7p\2\2\u00ea\u00eb\7v\2\2\u00eb\u00ec\7k\2\2\u00ec\u00ed\7p\2\2\u00ed"+
"\u00ee\7w\2\2\u00ee\u00ef\7g\2\2\u00ef%\3\2\2\2\u00f0\u00f1\7d\2\2\u00f1"+
"\u00f2\7t\2\2\u00f2\u00f3\7g\2\2\u00f3\u00f4\7c\2\2\u00f4\u00f5\7m\2\2"+
"\u00f5\'\3\2\2\2\u00f6\u00f7\7t\2\2\u00f7\u00f8\7g\2\2\u00f8\u00f9\7v"+
"\2\2\u00f9\u00fa\7w\2\2\u00fa\u00fb\7t\2\2\u00fb\u00fc\7p\2\2\u00fc)\3"+
"\2\2\2\u00fd\u00fe\7p\2\2\u00fe\u00ff\7g\2\2\u00ff\u0100\7y\2\2\u0100"+
"+\3\2\2\2\u0101\u0102\7v\2\2\u0102\u0103\7t\2\2\u0103\u0104\7{\2\2\u0104"+
"-\3\2\2\2\u0105\u0106\7e\2\2\u0106\u0107\7c\2\2\u0107\u0108\7v\2\2\u0108"+
"\u0109\7e\2\2\u0109\u010a\7j\2\2\u010a/\3\2\2\2\u010b\u010c\7v\2\2\u010c"+
"\u010d\7j\2\2\u010d\u010e\7t\2\2\u010e\u010f\7q\2\2\u010f\u0110\7y\2\2"+
"\u0110\61\3\2\2\2\u0111\u0112\7#\2\2\u0112\63\3\2\2\2\u0113\u0114\7\u0080"+
"\2\2\u0114\65\3\2\2\2\u0115\u0116\7,\2\2\u0116\67\3\2\2\2\u0117\u0118"+
"\7\61\2\2\u01189\3\2\2\2\u0119\u011a\7\'\2\2\u011a;\3\2\2\2\u011b\u011c"+
"\7-\2\2\u011c=\3\2\2\2\u011d\u011e\7/\2\2\u011e?\3\2\2\2\u011f\u0120\7"+
">\2\2\u0120\u0121\7>\2\2\u0121A\3\2\2\2\u0122\u0123\7@\2\2\u0123\u0124"+
"\7@\2\2\u0124C\3\2\2\2\u0125\u0126\7@\2\2\u0126\u0127\7@\2\2\u0127\u0128"+
"\7@\2\2\u0128E\3\2\2\2\u0129\u012a\7>\2\2\u012aG\3\2\2\2\u012b\u012c\7"+
">\2\2\u012c\u012d\7?\2\2\u012dI\3\2\2\2\u012e\u012f\7@\2\2\u012fK\3\2"+
"\2\2\u0130\u0131\7@\2\2\u0131\u0132\7?\2\2\u0132M\3\2\2\2\u0133\u0134"+
"\7?\2\2\u0134\u0135\7?\2\2\u0135O\3\2\2\2\u0136\u0137\7?\2\2\u0137\u0138"+
"\7?\2\2\u0138\u0139\7?\2\2\u0139Q\3\2\2\2\u013a\u013b\7#\2\2\u013b\u013c"+
"\7?\2\2\u013cS\3\2\2\2\u013d\u013e\7#\2\2\u013e\u013f\7?\2\2\u013f\u0140"+
"\7?\2\2\u0140U\3\2\2\2\u0141\u0142\7(\2\2\u0142W\3\2\2\2\u0143\u0144\7"+
"`\2\2\u0144Y\3\2\2\2\u0145\u0146\7~\2\2\u0146[\3\2\2\2\u0147\u0148\7("+
"\2\2\u0148\u0149\7(\2\2\u0149]\3\2\2\2\u014a\u014b\7~\2\2\u014b\u014c"+
"\7~\2\2\u014c_\3\2\2\2\u014d\u014e\7A\2\2\u014ea\3\2\2\2\u014f\u0150\7"+
"<\2\2\u0150c\3\2\2\2\u0151\u0152\7-\2\2\u0152\u0153\7-\2\2\u0153e\3\2"+
"\2\2\u0154\u0155\7/\2\2\u0155\u0156\7/\2\2\u0156g\3\2\2\2\u0157\u0158"+
"\7?\2\2\u0158i\3\2\2\2\u0159\u015a\7-\2\2\u015a\u015b\7?\2\2\u015bk\3"+
"\2\2\2\u015c\u015d\7/\2\2\u015d\u015e\7?\2\2\u015em\3\2\2\2\u015f\u0160"+
"\7,\2\2\u0160\u0161\7?\2\2\u0161o\3\2\2\2\u0162\u0163\7\61\2\2\u0163\u0164"+
"\7?\2\2\u0164q\3\2\2\2\u0165\u0166\7\'\2\2\u0166\u0167\7?\2\2\u0167s\3"+
"\2\2\2\u0168\u0169\7(\2\2\u0169\u016a\7?\2\2\u016au\3\2\2\2\u016b\u016c"+
"\7`\2\2\u016c\u016d\7?\2\2\u016dw\3\2\2\2\u016e\u016f\7~\2\2\u016f\u0170"+
"\7?\2\2\u0170y\3\2\2\2\u0171\u0172\7>\2\2\u0172\u0173\7>\2\2\u0173\u0174"+
"\7?\2\2\u0174{\3\2\2\2\u0175\u0176\7@\2\2\u0176\u0177\7@\2\2\u0177\u0178"+
"\7?\2\2\u0178}\3\2\2\2\u0179\u017a\7@\2\2\u017a\u017b\7@\2\2\u017b\u017c"+
"\7@\2\2\u017c\u017d\7?\2\2\u017d\177\3\2\2\2\u017e\u017f\7\60\2\2\u017f"+
"\u0180\7\60\2\2\u0180\u0181\7?\2\2\u0181\u0081\3\2\2\2\u0182\u0184\7\62"+
"\2\2\u0183\u0185\t\4\2\2\u0184\u0183\3\2\2\2\u0185\u0186\3\2\2\2\u0186"+
"\u0184\3\2\2\2\u0186\u0187\3\2\2\2\u0187\u0189\3\2\2\2\u0188\u018a\t\5"+
"\2\2\u0189\u0188\3\2\2\2\u0189\u018a\3\2\2\2\u018a\u0083\3\2\2\2\u018b"+
"\u018c\7\62\2\2\u018c\u018e\t\6\2\2\u018d\u018f\t\7\2\2\u018e\u018d\3"+
"\2\2\2\u018f\u0190\3\2\2\2\u0190\u018e\3\2\2\2\u0190\u0191\3\2\2\2\u0191"+
"\u0193\3\2\2\2\u0192\u0194\t\5\2\2\u0193\u0192\3\2\2\2\u0193\u0194\3\2"+
"\2\2\u0194\u0085\3\2\2\2\u0195\u019e\7\62\2\2\u0196\u019a\t\b\2\2\u0197"+
"\u0199\t\t\2\2\u0198\u0197\3\2\2\2\u0199\u019c\3\2\2\2\u019a\u0198\3\2"+
"\2\2\u019a\u019b\3\2\2\2\u019b\u019e\3\2\2\2\u019c\u019a\3\2\2\2\u019d"+
"\u0195\3\2\2\2\u019d\u0196\3\2\2\2\u019e\u01a0\3\2\2\2\u019f\u01a1\t\n"+
"\2\2\u01a0\u019f\3\2\2\2\u01a0\u01a1\3\2\2\2\u01a1\u0087\3\2\2\2\u01a2"+
"\u01ab\7\62\2\2\u01a3\u01a7\t\b\2\2\u01a4\u01a6\t\t\2\2\u01a5\u01a4\3"+
"\2\2\2\u01a6\u01a9\3\2\2\2\u01a7\u01a5\3\2\2\2\u01a7\u01a8\3\2\2\2\u01a8"+
"\u01ab\3\2\2\2\u01a9\u01a7\3\2\2\2\u01aa\u01a2\3\2\2\2\u01aa\u01a3\3\2"+
"\2\2\u01ab\u01ac\3\2\2\2\u01ac\u01b0\5\24\n\2\u01ad\u01af\t\t\2\2\u01ae"+
"\u01ad\3\2\2\2\u01af\u01b2\3\2\2\2\u01b0\u01ae\3\2\2\2\u01b0\u01b1\3\2"+
"\2\2\u01b1\u01bc\3\2\2\2\u01b2\u01b0\3\2\2\2\u01b3\u01b5\t\13\2\2\u01b4"+
"\u01b6\t\f\2\2\u01b5\u01b4\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01b8\3\2"+
"\2\2\u01b7\u01b9\t\t\2\2\u01b8\u01b7\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba"+
"\u01b8\3\2\2\2\u01ba\u01bb\3\2\2\2\u01bb\u01bd\3\2\2\2\u01bc\u01b3\3\2"+
"\2\2\u01bc\u01bd\3\2\2\2\u01bd\u01bf\3\2\2\2\u01be\u01c0\t\r\2\2\u01bf"+
"\u01be\3\2\2\2\u01bf\u01c0\3\2\2\2\u01c0\u0089\3\2\2\2\u01c1\u01c9\7$"+
"\2\2\u01c2\u01c3\7^\2\2\u01c3\u01c8\7$\2\2\u01c4\u01c5\7^\2\2\u01c5\u01c8"+
"\7^\2\2\u01c6\u01c8\n\16\2\2\u01c7\u01c2\3\2\2\2\u01c7\u01c4\3\2\2\2\u01c7"+
"\u01c6\3\2\2\2\u01c8\u01cb\3\2\2\2\u01c9\u01ca\3\2\2\2\u01c9\u01c7\3\2"+
"\2\2\u01ca\u01cc\3\2\2\2\u01cb\u01c9\3\2\2\2\u01cc\u01cd\7$\2\2\u01cd"+
"\u01ce\bE\4\2\u01ce\u008b\3\2\2\2\u01cf\u01d0\7)\2\2\u01d0\u01d1\13\2"+
"\2\2\u01d1\u01d2\7)\2\2\u01d2\u01d3\bF\5\2\u01d3\u008d\3\2\2\2\u01d4\u01d5"+
"\7v\2\2\u01d5\u01d6\7t\2\2\u01d6\u01d7\7w\2\2\u01d7\u01d8\7g\2\2\u01d8"+
"\u008f\3\2\2\2\u01d9\u01da\7h\2\2\u01da\u01db\7c\2\2\u01db\u01dc\7n\2"+
"\2\u01dc\u01dd\7u\2\2\u01dd\u01de\7g\2\2\u01de\u0091\3\2\2\2\u01df\u01e0"+
"\7p\2\2\u01e0\u01e1\7w\2\2\u01e1\u01e2\7n\2\2\u01e2\u01e3\7n\2\2\u01e3"+
"\u0093\3\2\2\2\u01e4\u01e6\5\u0098L\2\u01e5\u01e7\5\u0096K\2\u01e6\u01e5"+
"\3\2\2\2\u01e6\u01e7\3\2\2\2\u01e7\u01e8\3\2\2\2\u01e8\u01e9\6J\2\2\u01e9"+
"\u01ea\bJ\6\2\u01ea\u0095\3\2\2\2\u01eb\u01ed\7\"\2\2\u01ec\u01eb\3\2"+
"\2\2\u01ed\u01f0\3\2\2\2\u01ee\u01ec\3\2\2\2\u01ee\u01ef\3\2\2\2\u01ef"+
"\u01f1\3\2\2\2\u01f0\u01ee\3\2\2\2\u01f1\u01f5\7>\2\2\u01f2\u01f4\7\""+
"\2\2\u01f3\u01f2\3\2\2\2\u01f4\u01f7\3\2\2\2\u01f5\u01f3\3\2\2\2\u01f5"+
"\u01f6\3\2\2\2\u01f6\u01f8\3\2\2\2\u01f7\u01f5\3\2\2\2\u01f8\u01fa\5\u0098"+
"L\2\u01f9\u01fb\5\u0096K\2\u01fa\u01f9\3\2\2\2\u01fa\u01fb\3\2\2\2\u01fb"+
"\u01ff\3\2\2\2\u01fc\u01fe\7\"\2\2\u01fd\u01fc\3\2\2\2\u01fe\u0201\3\2"+
"\2\2\u01ff\u01fd\3\2\2\2\u01ff\u0200\3\2\2\2\u0200\u0215\3\2\2\2\u0201"+
"\u01ff\3\2\2\2\u0202\u0206\5\26\13\2\u0203\u0205\7\"\2\2\u0204\u0203\3"+
"\2\2\2\u0205\u0208\3\2\2\2\u0206\u0204\3\2\2\2\u0206\u0207\3\2\2\2\u0207"+
"\u0209\3\2\2\2\u0208\u0206\3\2\2\2\u0209\u020b\5\u0098L\2\u020a\u020c"+
"\5\u0096K\2\u020b\u020a\3\2\2\2\u020b\u020c\3\2\2\2\u020c\u0210\3\2\2"+
"\2\u020d\u020f\7\"\2\2\u020e\u020d\3\2\2\2\u020f\u0212\3\2\2\2\u0210\u020e"+
"\3\2\2\2\u0210\u0211\3\2\2\2\u0211\u0214\3\2\2\2\u0212\u0210\3\2\2\2\u0213"+
"\u0202\3\2\2\2\u0214\u0217\3\2\2\2\u0215\u0213\3\2\2\2\u0215\u0216\3\2"+
"\2\2\u0216\u0218\3\2\2\2\u0217\u0215\3\2\2\2\u0218\u0219\7@\2\2\u0219"+
"\u0097\3\2\2\2\u021a\u021e\t\17\2\2\u021b\u021d\t\20\2\2\u021c\u021b\3"+
"\2\2\2\u021d\u0220\3\2\2\2\u021e\u021c\3\2\2\2\u021e\u021f\3\2\2\2\u021f"+
"\u0099\3\2\2\2\u0220\u021e\3\2\2\2\u0221\u022a\7\62\2\2\u0222\u0226\t"+
"\b\2\2\u0223\u0225\t\t\2\2\u0224\u0223\3\2\2\2\u0225\u0228\3\2\2\2\u0226"+
"\u0224\3\2\2\2\u0226\u0227\3\2\2\2\u0227\u022a\3\2\2\2\u0228\u0226\3\2"+
"\2\2\u0229\u0221\3\2\2\2\u0229\u0222\3\2\2\2\u022a\u022b\3\2\2\2\u022b"+
"\u022c\bM\7\2\u022c\u009b\3\2\2\2\u022d\u0231\t\17\2\2\u022e\u0230\t\20"+
"\2\2\u022f\u022e\3\2\2\2\u0230\u0233\3\2\2\2\u0231\u022f\3\2\2\2\u0231"+
"\u0232\3\2\2\2\u0232\u0234\3\2\2\2\u0233\u0231\3\2\2\2\u0234\u0235\bN"+
"\7\2\u0235\u009d\3\2\2\2%\2\3\u00a1\u00ab\u00b5\u00ba\u0186\u0189\u0190"+
"\u0193\u019a\u019d\u01a0\u01a7\u01aa\u01b0\u01b5\u01ba\u01bc\u01bf\u01c7"+
"\u01c9\u01e6\u01ee\u01f5\u01fa\u01ff\u0206\u020b\u0210\u0215\u021e\u0226"+
"\u0229\u0231\b\b\2\2\4\3\2\3E\2\3F\3\3J\4\4\2\2";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}

2884
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/PlanAParser.java Normal file
View File

File diff suppressed because it is too large Load Diff

357
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/PlanAParserBaseVisitor.java Normal file
View File

@ -0,0 +1,357 @@
// ANTLR GENERATED CODE: DO NOT EDIT
package org.elasticsearch.plan.a;
import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
/**
* This class provides an empty implementation of {@link PlanAParserVisitor},
* which can be extended to create a visitor which only needs to handle a subset
* of the available methods.
*
* @param <T> The return type of the visit operation. Use {@link Void} for
* operations with no return type.
*/
class PlanAParserBaseVisitor<T> extends AbstractParseTreeVisitor<T> implements PlanAParserVisitor<T> {
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitSource(PlanAParser.SourceContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitIf(PlanAParser.IfContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitWhile(PlanAParser.WhileContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitDo(PlanAParser.DoContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitFor(PlanAParser.ForContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitDecl(PlanAParser.DeclContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitContinue(PlanAParser.ContinueContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitBreak(PlanAParser.BreakContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitReturn(PlanAParser.ReturnContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitTry(PlanAParser.TryContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitThrow(PlanAParser.ThrowContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitExpr(PlanAParser.ExprContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitMultiple(PlanAParser.MultipleContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitSingle(PlanAParser.SingleContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitEmpty(PlanAParser.EmptyContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitInitializer(PlanAParser.InitializerContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitAfterthought(PlanAParser.AfterthoughtContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitDeclaration(PlanAParser.DeclarationContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitDecltype(PlanAParser.DecltypeContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitDeclvar(PlanAParser.DeclvarContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitComp(PlanAParser.CompContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitBool(PlanAParser.BoolContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitConditional(PlanAParser.ConditionalContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitAssignment(PlanAParser.AssignmentContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitFalse(PlanAParser.FalseContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitNumeric(PlanAParser.NumericContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitUnary(PlanAParser.UnaryContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitPrecedence(PlanAParser.PrecedenceContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitPreinc(PlanAParser.PreincContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitPostinc(PlanAParser.PostincContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitCast(PlanAParser.CastContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitExternal(PlanAParser.ExternalContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitNull(PlanAParser.NullContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitBinary(PlanAParser.BinaryContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitChar(PlanAParser.CharContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitTrue(PlanAParser.TrueContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitExtstart(PlanAParser.ExtstartContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitExtprec(PlanAParser.ExtprecContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitExtcast(PlanAParser.ExtcastContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitExtbrace(PlanAParser.ExtbraceContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitExtdot(PlanAParser.ExtdotContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitExttype(PlanAParser.ExttypeContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitExtcall(PlanAParser.ExtcallContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitExtvar(PlanAParser.ExtvarContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitExtfield(PlanAParser.ExtfieldContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitExtnew(PlanAParser.ExtnewContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitExtstring(PlanAParser.ExtstringContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitArguments(PlanAParser.ArgumentsContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitIncrement(PlanAParser.IncrementContext ctx) { return visitChildren(ctx); }
}

336
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/PlanAParserVisitor.java Normal file
View File

@ -0,0 +1,336 @@
// ANTLR GENERATED CODE: DO NOT EDIT
package org.elasticsearch.plan.a;
import org.antlr.v4.runtime.tree.ParseTreeVisitor;
/**
* This interface defines a complete generic visitor for a parse tree produced
* by {@link PlanAParser}.
*
* @param <T> The return type of the visit operation. Use {@link Void} for
* operations with no return type.
*/
interface PlanAParserVisitor<T> extends ParseTreeVisitor<T> {
/**
* Visit a parse tree produced by {@link PlanAParser#source}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitSource(PlanAParser.SourceContext ctx);
/**
* Visit a parse tree produced by the {@code if}
* labeled alternative in {@link PlanAParser#statement}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitIf(PlanAParser.IfContext ctx);
/**
* Visit a parse tree produced by the {@code while}
* labeled alternative in {@link PlanAParser#statement}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitWhile(PlanAParser.WhileContext ctx);
/**
* Visit a parse tree produced by the {@code do}
* labeled alternative in {@link PlanAParser#statement}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitDo(PlanAParser.DoContext ctx);
/**
* Visit a parse tree produced by the {@code for}
* labeled alternative in {@link PlanAParser#statement}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitFor(PlanAParser.ForContext ctx);
/**
* Visit a parse tree produced by the {@code decl}
* labeled alternative in {@link PlanAParser#statement}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitDecl(PlanAParser.DeclContext ctx);
/**
* Visit a parse tree produced by the {@code continue}
* labeled alternative in {@link PlanAParser#statement}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitContinue(PlanAParser.ContinueContext ctx);
/**
* Visit a parse tree produced by the {@code break}
* labeled alternative in {@link PlanAParser#statement}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitBreak(PlanAParser.BreakContext ctx);
/**
* Visit a parse tree produced by the {@code return}
* labeled alternative in {@link PlanAParser#statement}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitReturn(PlanAParser.ReturnContext ctx);
/**
* Visit a parse tree produced by the {@code try}
* labeled alternative in {@link PlanAParser#statement}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitTry(PlanAParser.TryContext ctx);
/**
* Visit a parse tree produced by the {@code throw}
* labeled alternative in {@link PlanAParser#statement}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitThrow(PlanAParser.ThrowContext ctx);
/**
* Visit a parse tree produced by the {@code expr}
* labeled alternative in {@link PlanAParser#statement}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitExpr(PlanAParser.ExprContext ctx);
/**
* Visit a parse tree produced by the {@code multiple}
* labeled alternative in {@link PlanAParser#block}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitMultiple(PlanAParser.MultipleContext ctx);
/**
* Visit a parse tree produced by the {@code single}
* labeled alternative in {@link PlanAParser#block}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitSingle(PlanAParser.SingleContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#empty}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitEmpty(PlanAParser.EmptyContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#initializer}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitInitializer(PlanAParser.InitializerContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#afterthought}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitAfterthought(PlanAParser.AfterthoughtContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#declaration}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitDeclaration(PlanAParser.DeclarationContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#decltype}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitDecltype(PlanAParser.DecltypeContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#declvar}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitDeclvar(PlanAParser.DeclvarContext ctx);
/**
* Visit a parse tree produced by the {@code comp}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitComp(PlanAParser.CompContext ctx);
/**
* Visit a parse tree produced by the {@code bool}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitBool(PlanAParser.BoolContext ctx);
/**
* Visit a parse tree produced by the {@code conditional}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitConditional(PlanAParser.ConditionalContext ctx);
/**
* Visit a parse tree produced by the {@code assignment}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitAssignment(PlanAParser.AssignmentContext ctx);
/**
* Visit a parse tree produced by the {@code false}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitFalse(PlanAParser.FalseContext ctx);
/**
* Visit a parse tree produced by the {@code numeric}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitNumeric(PlanAParser.NumericContext ctx);
/**
* Visit a parse tree produced by the {@code unary}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitUnary(PlanAParser.UnaryContext ctx);
/**
* Visit a parse tree produced by the {@code precedence}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitPrecedence(PlanAParser.PrecedenceContext ctx);
/**
* Visit a parse tree produced by the {@code preinc}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitPreinc(PlanAParser.PreincContext ctx);
/**
* Visit a parse tree produced by the {@code postinc}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitPostinc(PlanAParser.PostincContext ctx);
/**
* Visit a parse tree produced by the {@code cast}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitCast(PlanAParser.CastContext ctx);
/**
* Visit a parse tree produced by the {@code external}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitExternal(PlanAParser.ExternalContext ctx);
/**
* Visit a parse tree produced by the {@code null}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitNull(PlanAParser.NullContext ctx);
/**
* Visit a parse tree produced by the {@code binary}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitBinary(PlanAParser.BinaryContext ctx);
/**
* Visit a parse tree produced by the {@code char}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitChar(PlanAParser.CharContext ctx);
/**
* Visit a parse tree produced by the {@code true}
* labeled alternative in {@link PlanAParser#expression}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitTrue(PlanAParser.TrueContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#extstart}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitExtstart(PlanAParser.ExtstartContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#extprec}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitExtprec(PlanAParser.ExtprecContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#extcast}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitExtcast(PlanAParser.ExtcastContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#extbrace}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitExtbrace(PlanAParser.ExtbraceContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#extdot}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitExtdot(PlanAParser.ExtdotContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#exttype}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitExttype(PlanAParser.ExttypeContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#extcall}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitExtcall(PlanAParser.ExtcallContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#extvar}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitExtvar(PlanAParser.ExtvarContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#extfield}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitExtfield(PlanAParser.ExtfieldContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#extnew}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitExtnew(PlanAParser.ExtnewContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#extstring}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitExtstring(PlanAParser.ExtstringContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#arguments}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitArguments(PlanAParser.ArgumentsContext ctx);
/**
* Visit a parse tree produced by {@link PlanAParser#increment}.
* @param ctx the parse tree
* @return the visitor result
*/
T visitIncrement(PlanAParser.IncrementContext ctx);
}

40
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/PlanAPlugin.java Normal file
View File

@ -0,0 +1,40 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import org.elasticsearch.plugins.Plugin;
import org.elasticsearch.script.ScriptModule;
public final class PlanAPlugin extends Plugin {
@Override
public String name() {
return "lang-plan-a";
}
@Override
public String description() {
return "Plan A scripting language for Elasticsearch";
}
public void onModule(ScriptModule module) {
module.addScriptEngine(PlanAScriptEngineService.class);
}
}

140
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/PlanAScriptEngineService.java Normal file
View File

@ -0,0 +1,140 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import org.apache.lucene.index.LeafReaderContext;
import org.elasticsearch.SpecialPermission;
import org.elasticsearch.common.component.AbstractComponent;
import org.elasticsearch.common.inject.Inject;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.script.CompiledScript;
import org.elasticsearch.script.ExecutableScript;
import org.elasticsearch.script.LeafSearchScript;
import org.elasticsearch.script.ScriptEngineService;
import org.elasticsearch.script.SearchScript;
import org.elasticsearch.search.lookup.SearchLookup;
import java.io.IOException;
import java.security.AccessControlContext;
import java.security.AccessController;
import java.security.Permissions;
import java.security.PrivilegedAction;
import java.security.ProtectionDomain;
import java.util.Map;
public class PlanAScriptEngineService extends AbstractComponent implements ScriptEngineService {
public static final String NAME = "plan-a";
// TODO: this should really be per-script since scripts do so many different things?
private static final CompilerSettings compilerSettings = new CompilerSettings();
public static final String NUMERIC_OVERFLOW = "plan-a.numeric_overflow";
// TODO: how should custom definitions be specified?
private Definition definition = null;
@Inject
public PlanAScriptEngineService(Settings settings) {
super(settings);
compilerSettings.setNumericOverflow(settings.getAsBoolean(NUMERIC_OVERFLOW, compilerSettings.getNumericOverflow()));
}
public void setDefinition(final Definition definition) {
this.definition = new Definition(definition);
}
@Override
public String[] types() {
return new String[] { NAME };
}
@Override
public String[] extensions() {
return new String[] { NAME };
}
@Override
public boolean sandboxed() {
return true;
}
// context used during compilation
private static final AccessControlContext COMPILATION_CONTEXT;
static {
Permissions none = new Permissions();
none.setReadOnly();
COMPILATION_CONTEXT = new AccessControlContext(new ProtectionDomain[] {
new ProtectionDomain(null, none)
});
}
@Override
public Object compile(String script) {
// check we ourselves are not being called by unprivileged code
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(new SpecialPermission());
}
// create our loader (which loads compiled code with no permissions)
Compiler.Loader loader = AccessController.doPrivileged(new PrivilegedAction<Compiler.Loader>() {
@Override
public Compiler.Loader run() {
return new Compiler.Loader(getClass().getClassLoader());
}
});
// drop all permissions to actually compile the code itself
return AccessController.doPrivileged(new PrivilegedAction<Executable>() {
@Override
public Executable run() {
return Compiler.compile(loader, "something", script, definition, compilerSettings);
}
}, COMPILATION_CONTEXT);
}
@Override
public ExecutableScript executable(CompiledScript compiledScript, Map<String,Object> vars) {
return new ScriptImpl((Executable) compiledScript.compiled(), vars, null);
}
@Override
public SearchScript search(CompiledScript compiledScript, SearchLookup lookup, Map<String,Object> vars) {
return new SearchScript() {
@Override
public LeafSearchScript getLeafSearchScript(LeafReaderContext context) throws IOException {
return new ScriptImpl((Executable) compiledScript.compiled(), vars, lookup.getLeafSearchLookup(context));
}
@Override
public boolean needsScores() {
return true; // TODO: maybe even do these different and more like expressions.
}
};
}
@Override
public void scriptRemoved(CompiledScript script) {
// nothing to do
}
@Override
public void close() throws IOException {
// nothing to do
}
}

96
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/ScriptImpl.java Normal file
View File

@ -0,0 +1,96 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import org.apache.lucene.search.Scorer;
import org.elasticsearch.script.ExecutableScript;
import org.elasticsearch.script.LeafSearchScript;
import org.elasticsearch.script.ScoreAccessor;
import org.elasticsearch.search.lookup.LeafSearchLookup;
import java.util.HashMap;
import java.util.Map;
final class ScriptImpl implements ExecutableScript, LeafSearchScript {
final Executable executable;
final Map<String,Object> variables;
final LeafSearchLookup lookup;
ScriptImpl(Executable executable, Map<String,Object> vars, LeafSearchLookup lookup) {
this.executable = executable;
this.lookup = lookup;
this.variables = new HashMap<>();
if (vars != null) {
variables.putAll(vars);
}
if (lookup != null) {
variables.putAll(lookup.asMap());
}
}
@Override
public void setNextVar(String name, Object value) {
variables.put(name, value);
}
@Override
public Object run() {
return executable.execute(variables);
}
@Override
public float runAsFloat() {
return ((Number) run()).floatValue();
}
@Override
public long runAsLong() {
return ((Number) run()).longValue();
}
@Override
public double runAsDouble() {
return ((Number) run()).doubleValue();
}
@Override
public Object unwrap(Object value) {
return value;
}
@Override
public void setScorer(Scorer scorer) {
variables.put("_score", new ScoreAccessor(scorer));
}
@Override
public void setDocument(int doc) {
if (lookup != null) {
lookup.setDocument(doc);
}
}
@Override
public void setSource(Map<String,Object> source) {
if (lookup != null) {
lookup.source().setSource(source);
}
}
}

801
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/Utility.java Normal file
View File

@ -0,0 +1,801 @@
package org.elasticsearch.plan.a;
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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.
*/
public class Utility {
public static boolean NumberToboolean(final Number value) {
return value.longValue() != 0;
}
public static char NumberTochar(final Number value) {
return (char)value.intValue();
}
public static Boolean NumberToBoolean(final Number value) {
return value.longValue() != 0;
}
public static Byte NumberToByte(final Number value) {
return value == null ? null : value.byteValue();
}
public static Short NumberToShort(final Number value) {
return value == null ? null : value.shortValue();
}
public static Character NumberToCharacter(final Number value) {
return value == null ? null : (char)value.intValue();
}
public static Integer NumberToInteger(final Number value) {
return value == null ? null : value.intValue();
}
public static Long NumberToLong(final Number value) {
return value == null ? null : value.longValue();
}
public static Float NumberToFloat(final Number value) {
return value == null ? null : value.floatValue();
}
public static Double NumberToDouble(final Number value) {
return value == null ? null : value.doubleValue();
}
public static byte booleanTobyte(final boolean value) {
return (byte)(value ? 1 : 0);
}
public static short booleanToshort(final boolean value) {
return (short)(value ? 1 : 0);
}
public static char booleanTochar(final boolean value) {
return (char)(value ? 1 : 0);
}
public static int booleanToint(final boolean value) {
return value ? 1 : 0;
}
public static long booleanTolong(final boolean value) {
return value ? 1 : 0;
}
public static float booleanTofloat(final boolean value) {
return value ? 1 : 0;
}
public static double booleanTodouble(final boolean value) {
return value ? 1 : 0;
}
public static Integer booleanToInteger(final boolean value) {
return value ? 1 : 0;
}
public static byte BooleanTobyte(final Boolean value) {
return (byte)(value ? 1 : 0);
}
public static short BooleanToshort(final Boolean value) {
return (short)(value ? 1 : 0);
}
public static char BooleanTochar(final Boolean value) {
return (char)(value ? 1 : 0);
}
public static int BooleanToint(final Boolean value) {
return value ? 1 : 0;
}
public static long BooleanTolong(final Boolean value) {
return value ? 1 : 0;
}
public static float BooleanTofloat(final Boolean value) {
return value ? 1 : 0;
}
public static double BooleanTodouble(final Boolean value) {
return value ? 1 : 0;
}
public static Byte BooleanToByte(final Boolean value) {
return value == null ? null : (byte)(value ? 1 : 0);
}
public static Short BooleanToShort(final Boolean value) {
return value == null ? null : (short)(value ? 1 : 0);
}
public static Character BooleanToCharacter(final Boolean value) {
return value == null ? null : (char)(value ? 1 : 0);
}
public static Integer BooleanToInteger(final Boolean value) {
return value == null ? null : value ? 1 : 0;
}
public static Long BooleanToLong(final Boolean value) {
return value == null ? null : value ? 1L : 0L;
}
public static Float BooleanToFloat(final Boolean value) {
return value == null ? null : value ? 1F : 0F;
}
public static Double BooleanToDouble(final Boolean value) {
return value == null ? null : value ? 1D : 0D;
}
public static boolean byteToboolean(final byte value) {
return value != 0;
}
public static Short byteToShort(final byte value) {
return (short)value;
}
public static Character byteToCharacter(final byte value) {
return (char)(byte)value;
}
public static Integer byteToInteger(final byte value) {
return (int)value;
}
public static Long byteToLong(final byte value) {
return (long)value;
}
public static Float byteToFloat(final byte value) {
return (float)value;
}
public static Double byteToDouble(final byte value) {
return (double)value;
}
public static boolean ByteToboolean(final Byte value) {
return value != 0;
}
public static char ByteTochar(final Byte value) {
return (char)value.byteValue();
}
public static boolean shortToboolean(final short value) {
return value != 0;
}
public static Byte shortToByte(final short value) {
return (byte)value;
}
public static Character shortToCharacter(final short value) {
return (char)(short)value;
}
public static Integer shortToInteger(final short value) {
return (int)value;
}
public static Long shortToLong(final short value) {
return (long)value;
}
public static Float shortToFloat(final short value) {
return (float)value;
}
public static Double shortToDouble(final short value) {
return (double)value;
}
public static boolean ShortToboolean(final Short value) {
return value != 0;
}
public static char ShortTochar(final Short value) {
return (char)value.shortValue();
}
public static boolean charToboolean(final char value) {
return value != 0;
}
public static Byte charToByte(final char value) {
return (byte)value;
}
public static Short charToShort(final char value) {
return (short)value;
}
public static Integer charToInteger(final char value) {
return (int)value;
}
public static Long charToLong(final char value) {
return (long)value;
}
public static Float charToFloat(final char value) {
return (float)value;
}
public static Double charToDouble(final char value) {
return (double)value;
}
public static boolean CharacterToboolean(final Character value) {
return value != 0;
}
public static byte CharacterTobyte(final Character value) {
return (byte)value.charValue();
}
public static short CharacterToshort(final Character value) {
return (short)value.charValue();
}
public static int CharacterToint(final Character value) {
return (int)value;
}
public static long CharacterTolong(final Character value) {
return (long)value;
}
public static float CharacterTofloat(final Character value) {
return (float)value;
}
public static double CharacterTodouble(final Character value) {
return (double)value;
}
public static Boolean CharacterToBoolean(final Character value) {
return value == null ? null : value != 0;
}
public static Byte CharacterToByte(final Character value) {
return value == null ? null : (byte)value.charValue();
}
public static Short CharacterToShort(final Character value) {
return value == null ? null : (short)value.charValue();
}
public static Integer CharacterToInteger(final Character value) {
return value == null ? null : (int)value;
}
public static Long CharacterToLong(final Character value) {
return value == null ? null : (long)value;
}
public static Float CharacterToFloat(final Character value) {
return value == null ? null : (float)value;
}
public static Double CharacterToDouble(final Character value) {
return value == null ? null : (double)value;
}
public static boolean intToboolean(final int value) {
return value != 0;
}
public static Byte intToByte(final int value) {
return (byte)value;
}
public static Short intToShort(final int value) {
return (short)value;
}
public static Character intToCharacter(final int value) {
return (char)(int)value;
}
public static Long intToLong(final int value) {
return (long)value;
}
public static Float intToFloat(final int value) {
return (float)value;
}
public static Double intToDouble(final int value) {
return (double)value;
}
public static boolean IntegerToboolean(final Integer value) {
return value != 0;
}
public static char IntegerTochar(final Integer value) {
return (char)value.intValue();
}
public static boolean longToboolean(final long value) {
return value != 0;
}
public static Byte longToByte(final long value) {
return (byte)value;
}
public static Short longToShort(final long value) {
return (short)value;
}
public static Character longToCharacter(final long value) {
return (char)(long)value;
}
public static Integer longToInteger(final long value) {
return (int)value;
}
public static Float longToFloat(final long value) {
return (float)value;
}
public static Double longToDouble(final long value) {
return (double)value;
}
public static boolean LongToboolean(final Long value) {
return value != 0;
}
public static char LongTochar(final Long value) {
return (char)value.longValue();
}
public static boolean floatToboolean(final float value) {
return value != 0;
}
public static Byte floatToByte(final float value) {
return (byte)value;
}
public static Short floatToShort(final float value) {
return (short)value;
}
public static Character floatToCharacter(final float value) {
return (char)(float)value;
}
public static Integer floatToInteger(final float value) {
return (int)value;
}
public static Long floatToLong(final float value) {
return (long)value;
}
public static Double floatToDouble(final float value) {
return (double)value;
}
public static boolean FloatToboolean(final Float value) {
return value != 0;
}
public static char FloatTochar(final Float value) {
return (char)value.floatValue();
}
public static boolean doubleToboolean(final double value) {
return value != 0;
}
public static Byte doubleToByte(final double value) {
return (byte)value;
}
public static Short doubleToShort(final double value) {
return (short)value;
}
public static Character doubleToCharacter(final double value) {
return (char)(double)value;
}
public static Integer doubleToInteger(final double value) {
return (int)value;
}
public static Long doubleToLong(final double value) {
return (long)value;
}
public static Float doubleToFloat(final double value) {
return (float)value;
}
public static boolean DoubleToboolean(final Double value) {
return value != 0;
}
public static char DoubleTochar(final Double value) {
return (char)value.doubleValue();
}
// although divide by zero is guaranteed, the special overflow case is not caught.
// its not needed for remainder because it is not possible there.
// see https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.2
/**
* Integer divide without overflow
* @throws ArithmeticException on overflow or divide-by-zero
*/
public static int divideWithoutOverflow(int x, int y) {
if (x == Integer.MIN_VALUE && y == -1) {
throw new ArithmeticException("integer overflow");
}
return x / y;
}
/**
* Long divide without overflow
* @throws ArithmeticException on overflow or divide-by-zero
*/
public static long divideWithoutOverflow(long x, long y) {
if (x == Long.MIN_VALUE && y == -1L) {
throw new ArithmeticException("long overflow");
}
return x / y;
}
// byte, short, and char are promoted to int for normal operations,
// so the JDK exact methods are typically used, and the result has a wider range.
// but compound assignments and increment/decrement operators (e.g. byte b = Byte.MAX_VALUE; b++;)
// implicitly cast back to the original type: so these need to be checked against the original range.
/**
* Like {@link Math#toIntExact(long)} but for byte range.
*/
public static byte toByteExact(int value) {
byte s = (byte) value;
if (s != value) {
throw new ArithmeticException("byte overflow");
}
return s;
}
/**
* Like {@link Math#toIntExact(long)} but for byte range.
*/
public static byte toByteExact(long value) {
byte s = (byte) value;
if (s != value) {
throw new ArithmeticException("byte overflow");
}
return s;
}
/**
* Like {@link Math#toIntExact(long)} but for byte range.
*/
public static byte toByteWithoutOverflow(float value) {
if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
throw new ArithmeticException("byte overflow");
}
return (byte)value;
}
/**
* Like {@link Math#toIntExact(long)} but for byte range.
*/
public static byte toByteWithoutOverflow(double value) {
if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
throw new ArithmeticException("byte overflow");
}
return (byte)value;
}
/**
* Like {@link Math#toIntExact(long)} but for short range.
*/
public static short toShortExact(int value) {
short s = (short) value;
if (s != value) {
throw new ArithmeticException("short overflow");
}
return s;
}
/**
* Like {@link Math#toIntExact(long)} but for short range.
*/
public static short toShortExact(long value) {
short s = (short) value;
if (s != value) {
throw new ArithmeticException("short overflow");
}
return s;
}
/**
* Like {@link Math#toIntExact(long)} but for short range.
*/
public static short toShortWithoutOverflow(float value) {
if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
throw new ArithmeticException("short overflow");
}
return (short)value;
}
/**
* Like {@link Math#toIntExact(long)} but for short range.
*/
public static short toShortExact(double value) {
if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
throw new ArithmeticException("short overflow");
}
return (short)value;
}
/**
* Like {@link Math#toIntExact(long)} but for char range.
*/
public static char toCharExact(int value) {
char s = (char) value;
if (s != value) {
throw new ArithmeticException("char overflow");
}
return s;
}
/**
* Like {@link Math#toIntExact(long)} but for char range.
*/
public static char toCharExact(long value) {
char s = (char) value;
if (s != value) {
throw new ArithmeticException("char overflow");
}
return s;
}
/**
* Like {@link Math#toIntExact(long)} but for char range.
*/
public static char toCharWithoutOverflow(float value) {
if (value < Character.MIN_VALUE || value > Character.MAX_VALUE) {
throw new ArithmeticException("char overflow");
}
return (char)value;
}
/**
* Like {@link Math#toIntExact(long)} but for char range.
*/
public static char toCharWithoutOverflow(double value) {
if (value < Character.MIN_VALUE || value > Character.MAX_VALUE) {
throw new ArithmeticException("char overflow");
}
return (char)value;
}
/**
* Like {@link Math#toIntExact(long)} but for int range.
*/
public static int toIntWithoutOverflow(float value) {
if (value < Integer.MIN_VALUE || value > Integer.MAX_VALUE) {
throw new ArithmeticException("int overflow");
}
return (int)value;
}
/**
* Like {@link Math#toIntExact(long)} but for int range.
*/
public static int toIntWithoutOverflow(double value) {
if (value < Integer.MIN_VALUE || value > Integer.MAX_VALUE) {
throw new ArithmeticException("int overflow");
}
return (int)value;
}
/**
* Like {@link Math#toIntExact(long)} but for long range.
*/
public static long toLongExactWithoutOverflow(float value) {
if (value < Long.MIN_VALUE || value > Long.MAX_VALUE) {
throw new ArithmeticException("long overflow");
}
return (long)value;
}
/**
* Like {@link Math#toIntExact(long)} but for long range.
*/
public static float toLongExactWithoutOverflow(double value) {
if (value < Long.MIN_VALUE || value > Long.MAX_VALUE) {
throw new ArithmeticException("long overflow");
}
return (long)value;
}
/**
* Like {@link Math#toIntExact(long)} but for float range.
*/
public static float toFloatWithoutOverflow(double value) {
if (value < Float.MIN_VALUE || value > Float.MAX_VALUE) {
throw new ArithmeticException("float overflow");
}
return (float)value;
}
/**
* Checks for overflow, result is infinite but operands are finite
* @throws ArithmeticException if overflow occurred
*/
private static float checkInfFloat(float x, float y, float z) {
if (Float.isInfinite(z)) {
if (Float.isFinite(x) && Float.isFinite(y)) {
throw new ArithmeticException("float overflow");
}
}
return z;
}
/**
* Checks for NaN, result is NaN but operands are finite
* @throws ArithmeticException if overflow occurred
*/
private static float checkNaNFloat(float x, float y, float z) {
if (Float.isNaN(z)) {
if (Float.isFinite(x) && Float.isFinite(y)) {
throw new ArithmeticException("NaN");
}
}
return z;
}
/**
* Checks for NaN, result is infinite but operands are finite
* @throws ArithmeticException if overflow occurred
*/
private static double checkInfDouble(double x, double y, double z) {
if (Double.isInfinite(z)) {
if (Double.isFinite(x) && Double.isFinite(y)) {
throw new ArithmeticException("double overflow");
}
}
return z;
}
/**
* Checks for NaN, result is NaN but operands are finite
* @throws ArithmeticException if overflow occurred
*/
private static double checkNaNDouble(double x, double y, double z) {
if (Double.isNaN(z)) {
if (Double.isFinite(x) && Double.isFinite(y)) {
throw new ArithmeticException("NaN");
}
}
return z;
}
/**
* Adds two floats but throws {@code ArithmeticException}
* if the result overflows.
*/
public static float addWithoutOverflow(float x, float y) {
return checkInfFloat(x, y, x + y);
}
/**
* Adds two doubles but throws {@code ArithmeticException}
* if the result overflows.
*/
public static double addWithoutOverflow(double x, double y) {
return checkInfDouble(x, y, x + y);
}
/**
* Subtracts two floats but throws {@code ArithmeticException}
* if the result overflows.
*/
public static float subtractWithoutOverflow(float x, float y) {
return checkInfFloat(x, y, x - y);
}
/**
* Subtracts two doubles but throws {@code ArithmeticException}
* if the result overflows.
*/
public static double subtractWithoutOverflow(double x, double y) {
return checkInfDouble(x, y , x - y);
}
/**
* Multiplies two floats but throws {@code ArithmeticException}
* if the result overflows.
*/
public static float multiplyWithoutOverflow(float x, float y) {
return checkInfFloat(x, y, x * y);
}
/**
* Multiplies two doubles but throws {@code ArithmeticException}
* if the result overflows.
*/
public static double multiplyWithoutOverflow(double x, double y) {
return checkInfDouble(x, y, x * y);
}
/**
* Divides two floats but throws {@code ArithmeticException}
* if the result overflows, or would create NaN from finite
* inputs ({@code x == 0, y == 0})
*/
public static float divideWithoutOverflow(float x, float y) {
return checkNaNFloat(x, y, checkInfFloat(x, y, x / y));
}
/**
* Divides two doubles but throws {@code ArithmeticException}
* if the result overflows, or would create NaN from finite
* inputs ({@code x == 0, y == 0})
*/
public static double divideWithoutOverflow(double x, double y) {
return checkNaNDouble(x, y, checkInfDouble(x, y, x / y));
}
/**
* Takes remainder two floats but throws {@code ArithmeticException}
* if the result would create NaN from finite inputs ({@code y == 0})
*/
public static float remainderWithoutOverflow(float x, float y) {
return checkNaNFloat(x, y, x % y);
}
/**
* Divides two doubles but throws {@code ArithmeticException}
* if the result would create NaN from finite inputs ({@code y == 0})
*/
public static double remainderWithoutOverflow(double x, double y) {
return checkNaNDouble(x, y, x % y);
}
public static boolean checkEquals(final Object left, final Object right) {
if (left != null && right != null) {
return left.equals(right);
}
return left == null && right == null;
}
private Utility() {}
}

2224
plugins/lang-plan-a/src/main/java/org/elasticsearch/plan/a/Writer.java Normal file
View File

File diff suppressed because it is too large Load Diff

23
plugins/lang-plan-a/src/main/plugin-metadata/plugin-security.policy Normal file
View File

@ -0,0 +1,23 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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.
*/
grant {
// needed to generate runtime classes
permission java.lang.RuntimePermission "createClassLoader";
};

199
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/AdditionTests.java Normal file
View File

@ -0,0 +1,199 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.util.HashMap;
import java.util.Map;
/** Tests for addition operator across all types */
//TODO: NaN/Inf/overflow/...
public class AdditionTests extends ScriptTestCase {
public void testInt() throws Exception {
assertEquals(1+1, exec("int x = 1; int y = 1; return x+y;"));
assertEquals(1+2, exec("int x = 1; int y = 2; return x+y;"));
assertEquals(5+10, exec("int x = 5; int y = 10; return x+y;"));
assertEquals(1+1+2, exec("int x = 1; int y = 1; int z = 2; return x+y+z;"));
assertEquals((1+1)+2, exec("int x = 1; int y = 1; int z = 2; return (x+y)+z;"));
assertEquals(1+(1+2), exec("int x = 1; int y = 1; int z = 2; return x+(y+z);"));
assertEquals(0+1, exec("int x = 0; int y = 1; return x+y;"));
assertEquals(1+0, exec("int x = 1; int y = 0; return x+y;"));
assertEquals(0+0, exec("int x = 0; int y = 0; return x+y;"));
assertEquals(0+0, exec("int x = 0; int y = 0; return x+y;"));
}
public void testIntConst() throws Exception {
assertEquals(1+1, exec("return 1+1;"));
assertEquals(1+2, exec("return 1+2;"));
assertEquals(5+10, exec("return 5+10;"));
assertEquals(1+1+2, exec("return 1+1+2;"));
assertEquals((1+1)+2, exec("return (1+1)+2;"));
assertEquals(1+(1+2), exec("return 1+(1+2);"));
assertEquals(0+1, exec("return 0+1;"));
assertEquals(1+0, exec("return 1+0;"));
assertEquals(0+0, exec("return 0+0;"));
}
public void testByte() throws Exception {
assertEquals((byte)1+(byte)1, exec("byte x = 1; byte y = 1; return x+y;"));
assertEquals((byte)1+(byte)2, exec("byte x = 1; byte y = 2; return x+y;"));
assertEquals((byte)5+(byte)10, exec("byte x = 5; byte y = 10; return x+y;"));
assertEquals((byte)1+(byte)1+(byte)2, exec("byte x = 1; byte y = 1; byte z = 2; return x+y+z;"));
assertEquals(((byte)1+(byte)1)+(byte)2, exec("byte x = 1; byte y = 1; byte z = 2; return (x+y)+z;"));
assertEquals((byte)1+((byte)1+(byte)2), exec("byte x = 1; byte y = 1; byte z = 2; return x+(y+z);"));
assertEquals((byte)0+(byte)1, exec("byte x = 0; byte y = 1; return x+y;"));
assertEquals((byte)1+(byte)0, exec("byte x = 1; byte y = 0; return x+y;"));
assertEquals((byte)0+(byte)0, exec("byte x = 0; byte y = 0; return x+y;"));
}
public void testByteConst() throws Exception {
assertEquals((byte)1+(byte)1, exec("return (byte)1+(byte)1;"));
assertEquals((byte)1+(byte)2, exec("return (byte)1+(byte)2;"));
assertEquals((byte)5+(byte)10, exec("return (byte)5+(byte)10;"));
assertEquals((byte)1+(byte)1+(byte)2, exec("return (byte)1+(byte)1+(byte)2;"));
assertEquals(((byte)1+(byte)1)+(byte)2, exec("return ((byte)1+(byte)1)+(byte)2;"));
assertEquals((byte)1+((byte)1+(byte)2), exec("return (byte)1+((byte)1+(byte)2);"));
assertEquals((byte)0+(byte)1, exec("return (byte)0+(byte)1;"));
assertEquals((byte)1+(byte)0, exec("return (byte)1+(byte)0;"));
assertEquals((byte)0+(byte)0, exec("return (byte)0+(byte)0;"));
}
public void testChar() throws Exception {
assertEquals((char)1+(char)1, exec("char x = 1; char y = 1; return x+y;"));
assertEquals((char)1+(char)2, exec("char x = 1; char y = 2; return x+y;"));
assertEquals((char)5+(char)10, exec("char x = 5; char y = 10; return x+y;"));
assertEquals((char)1+(char)1+(char)2, exec("char x = 1; char y = 1; char z = 2; return x+y+z;"));
assertEquals(((char)1+(char)1)+(char)2, exec("char x = 1; char y = 1; char z = 2; return (x+y)+z;"));
assertEquals((char)1+((char)1+(char)2), exec("char x = 1; char y = 1; char z = 2; return x+(y+z);"));
assertEquals((char)0+(char)1, exec("char x = 0; char y = 1; return x+y;"));
assertEquals((char)1+(char)0, exec("char x = 1; char y = 0; return x+y;"));
assertEquals((char)0+(char)0, exec("char x = 0; char y = 0; return x+y;"));
}
public void testCharConst() throws Exception {
assertEquals((char)1+(char)1, exec("return (char)1+(char)1;"));
assertEquals((char)1+(char)2, exec("return (char)1+(char)2;"));
assertEquals((char)5+(char)10, exec("return (char)5+(char)10;"));
assertEquals((char)1+(char)1+(char)2, exec("return (char)1+(char)1+(char)2;"));
assertEquals(((char)1+(char)1)+(char)2, exec("return ((char)1+(char)1)+(char)2;"));
assertEquals((char)1+((char)1+(char)2), exec("return (char)1+((char)1+(char)2);"));
assertEquals((char)0+(char)1, exec("return (char)0+(char)1;"));
assertEquals((char)1+(char)0, exec("return (char)1+(char)0;"));
assertEquals((char)0+(char)0, exec("return (char)0+(char)0;"));
}
public void testShort() throws Exception {
assertEquals((short)1+(short)1, exec("short x = 1; short y = 1; return x+y;"));
assertEquals((short)1+(short)2, exec("short x = 1; short y = 2; return x+y;"));
assertEquals((short)5+(short)10, exec("short x = 5; short y = 10; return x+y;"));
assertEquals((short)1+(short)1+(short)2, exec("short x = 1; short y = 1; short z = 2; return x+y+z;"));
assertEquals(((short)1+(short)1)+(short)2, exec("short x = 1; short y = 1; short z = 2; return (x+y)+z;"));
assertEquals((short)1+((short)1+(short)2), exec("short x = 1; short y = 1; short z = 2; return x+(y+z);"));
assertEquals((short)0+(short)1, exec("short x = 0; short y = 1; return x+y;"));
assertEquals((short)1+(short)0, exec("short x = 1; short y = 0; return x+y;"));
assertEquals((short)0+(short)0, exec("short x = 0; short y = 0; return x+y;"));
}
public void testShortConst() throws Exception {
assertEquals((short)1+(short)1, exec("return (short)1+(short)1;"));
assertEquals((short)1+(short)2, exec("return (short)1+(short)2;"));
assertEquals((short)5+(short)10, exec("return (short)5+(short)10;"));
assertEquals((short)1+(short)1+(short)2, exec("return (short)1+(short)1+(short)2;"));
assertEquals(((short)1+(short)1)+(short)2, exec("return ((short)1+(short)1)+(short)2;"));
assertEquals((short)1+((short)1+(short)2), exec("return (short)1+((short)1+(short)2);"));
assertEquals((short)0+(short)1, exec("return (short)0+(short)1;"));
assertEquals((short)1+(short)0, exec("return (short)1+(short)0;"));
assertEquals((short)0+(short)0, exec("return (short)0+(short)0;"));
}
public void testLong() throws Exception {
assertEquals(1L+1L, exec("long x = 1; long y = 1; return x+y;"));
assertEquals(1L+2L, exec("long x = 1; long y = 2; return x+y;"));
assertEquals(5L+10L, exec("long x = 5; long y = 10; return x+y;"));
assertEquals(1L+1L+2L, exec("long x = 1; long y = 1; long z = 2; return x+y+z;"));
assertEquals((1L+1L)+2L, exec("long x = 1; long y = 1; long z = 2; return (x+y)+z;"));
assertEquals(1L+(1L+2L), exec("long x = 1; long y = 1; long z = 2; return x+(y+z);"));
assertEquals(0L+1L, exec("long x = 0; long y = 1; return x+y;"));
assertEquals(1L+0L, exec("long x = 1; long y = 0; return x+y;"));
assertEquals(0L+0L, exec("long x = 0; long y = 0; return x+y;"));
}
public void testLongConst() throws Exception {
assertEquals(1L+1L, exec("return 1L+1L;"));
assertEquals(1L+2L, exec("return 1L+2L;"));
assertEquals(5L+10L, exec("return 5L+10L;"));
assertEquals(1L+1L+2L, exec("return 1L+1L+2L;"));
assertEquals((1L+1L)+2L, exec("return (1L+1L)+2L;"));
assertEquals(1L+(1L+2L), exec("return 1L+(1L+2L);"));
assertEquals(0L+1L, exec("return 0L+1L;"));
assertEquals(1L+0L, exec("return 1L+0L;"));
assertEquals(0L+0L, exec("return 0L+0L;"));
}
public void testFloat() throws Exception {
assertEquals(1F+1F, exec("float x = 1F; float y = 1F; return x+y;"));
assertEquals(1F+2F, exec("float x = 1F; float y = 2F; return x+y;"));
assertEquals(5F+10F, exec("float x = 5F; float y = 10F; return x+y;"));
assertEquals(1F+1F+2F, exec("float x = 1F; float y = 1F; float z = 2F; return x+y+z;"));
assertEquals((1F+1F)+2F, exec("float x = 1F; float y = 1F; float z = 2F; return (x+y)+z;"));
assertEquals((1F+1F)+2F, exec("float x = 1F; float y = 1F; float z = 2F; return x+(y+z);"));
assertEquals(0F+1F, exec("float x = 0F; float y = 1F; return x+y;"));
assertEquals(1F+0F, exec("float x = 1F; float y = 0F; return x+y;"));
assertEquals(0F+0F, exec("float x = 0F; float y = 0F; return x+y;"));
}
public void testFloatConst() throws Exception {
assertEquals(1F+1F, exec("return 1F+1F;"));
assertEquals(1F+2F, exec("return 1F+2F;"));
assertEquals(5F+10F, exec("return 5F+10F;"));
assertEquals(1F+1F+2F, exec("return 1F+1F+2F;"));
assertEquals((1F+1F)+2F, exec("return (1F+1F)+2F;"));
assertEquals(1F+(1F+2F), exec("return 1F+(1F+2F);"));
assertEquals(0F+1F, exec("return 0F+1F;"));
assertEquals(1F+0F, exec("return 1F+0F;"));
assertEquals(0F+0F, exec("return 0F+0F;"));
}
public void testDouble() throws Exception {
assertEquals(1.0+1.0, exec("double x = 1.0; double y = 1.0; return x+y;"));
assertEquals(1.0+2.0, exec("double x = 1.0; double y = 2.0; return x+y;"));
assertEquals(5.0+10.0, exec("double x = 5.0; double y = 10.0; return x+y;"));
assertEquals(1.0+1.0+2.0, exec("double x = 1.0; double y = 1.0; double z = 2.0; return x+y+z;"));
assertEquals((1.0+1.0)+2.0, exec("double x = 1.0; double y = 1.0; double z = 2.0; return (x+y)+z;"));
assertEquals(1.0+(1.0+2.0), exec("double x = 1.0; double y = 1.0; double z = 2.0; return x+(y+z);"));
assertEquals(0.0+1.0, exec("double x = 0.0; double y = 1.0; return x+y;"));
assertEquals(1.0+0.0, exec("double x = 1.0; double y = 0.0; return x+y;"));
assertEquals(0.0+0.0, exec("double x = 0.0; double y = 0.0; return x+y;"));
}
public void testDoubleConst() throws Exception {
assertEquals(1.0+1.0, exec("return 1.0+1.0;"));
assertEquals(1.0+2.0, exec("return 1.0+2.0;"));
assertEquals(5.0+10.0, exec("return 5.0+10.0;"));
assertEquals(1.0+1.0+2.0, exec("return 1.0+1.0+2.0;"));
assertEquals((1.0+1.0)+2.0, exec("return (1.0+1.0)+2.0;"));
assertEquals(1.0+(1.0+2.0), exec("return 1.0+(1.0+2.0);"));
assertEquals(0.0+1.0, exec("return 0.0+1.0;"));
assertEquals(1.0+0.0, exec("return 1.0+0.0;"));
assertEquals(0.0+0.0, exec("return 0.0+0.0;"));
}
}

48
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/AndTests.java Normal file
View File

@ -0,0 +1,48 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
/** Tests for and operator across all types */
public class AndTests extends ScriptTestCase {
public void testInt() throws Exception {
assertEquals(5 & 12, exec("int x = 5; int y = 12; return x & y;"));
assertEquals(5 & -12, exec("int x = 5; int y = -12; return x & y;"));
assertEquals(7 & 15 & 3, exec("int x = 7; int y = 15; int z = 3; return x & y & z;"));
}
public void testIntConst() throws Exception {
assertEquals(5 & 12, exec("return 5 & 12;"));
assertEquals(5 & -12, exec("return 5 & -12;"));
assertEquals(7 & 15 & 3, exec("return 7 & 15 & 3;"));
}
public void testLong() throws Exception {
assertEquals(5L & 12L, exec("long x = 5; long y = 12; return x & y;"));
assertEquals(5L & -12L, exec("long x = 5; long y = -12; return x & y;"));
assertEquals(7L & 15L & 3L, exec("long x = 7; long y = 15; long z = 3; return x & y & z;"));
}
public void testLongConst() throws Exception {
assertEquals(5L & 12L, exec("return 5L & 12L;"));
assertEquals(5L & -12L, exec("return 5L & -12L;"));
assertEquals(7L & 15L & 3L, exec("return 7L & 15L & 3L;"));
}
}

126
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/BasicExpressionTests.java Normal file
View File

@ -0,0 +1,126 @@
package org.elasticsearch.plan.a;
import java.util.Collections;
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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.
*/
public class BasicExpressionTests extends ScriptTestCase {
/** simple tests returning a constant value */
public void testReturnConstant() {
assertEquals(5, exec("return 5;"));
assertEquals(7L, exec("return 7L;"));
assertEquals(7.0, exec("return 7.0;"));
assertEquals(32.0F, exec("return 32.0F;"));
assertEquals((byte)255, exec("return (byte)255;"));
assertEquals((short)5, exec("return (short)5;"));
assertEquals("string", exec("return \"string\";"));
assertEquals(true, exec("return true;"));
assertEquals(false, exec("return false;"));
assertNull(exec("return null;"));
}
public void testReturnConstantChar() {
assertEquals('x', exec("return 'x';"));
}
public void testConstantCharTruncation() {
assertEquals('蚠', exec("return (char)100000;"));
}
/** declaring variables for primitive types */
public void testDeclareVariable() {
assertEquals(5, exec("int i = 5; return i;"));
assertEquals(7L, exec("long l = 7; return l;"));
assertEquals(7.0, exec("double d = 7; return d;"));
assertEquals(32.0F, exec("float f = 32F; return f;"));
assertEquals((byte)255, exec("byte b = (byte)255; return b;"));
assertEquals((short)5, exec("short s = (short)5; return s;"));
assertEquals("string", exec("String s = \"string\"; return s;"));
assertEquals(true, exec("boolean v = true; return v;"));
assertEquals(false, exec("boolean v = false; return v;"));
}
public void testCast() {
assertEquals(1, exec("return (int)1.0;"));
assertEquals((byte)100, exec("double x = 100; return (byte)x;"));
assertEquals(3, exec(
"Map x = new HashMap();\n" +
"Object y = x;\n" +
"((Map)y).put(2, 3);\n" +
"return x.get(2);\n"));
}
public void testCat() {
assertEquals("aaabbb", exec("return \"aaa\" + \"bbb\";"));
assertEquals("aaabbb", exec("String aaa = \"aaa\", bbb = \"bbb\"; return aaa + bbb;"));
assertEquals("aaabbbbbbbbb", exec(
"String aaa = \"aaa\", bbb = \"bbb\"; int x;\n" +
"for (; x < 3; ++x) \n" +
" aaa += bbb;\n" +
"return aaa;"));
}
public void testComp() {
assertEquals(true, exec("return 2 < 3;"));
assertEquals(false, exec("int x = 4; char y = 2; return x < y;"));
assertEquals(true, exec("return 3 <= 3;"));
assertEquals(true, exec("int x = 3; char y = 3; return x <= y;"));
assertEquals(false, exec("return 2 > 3;"));
assertEquals(true, exec("int x = 4; long y = 2; return x > y;"));
assertEquals(false, exec("return 3 >= 4;"));
assertEquals(true, exec("double x = 3; float y = 3; return x >= y;"));
assertEquals(false, exec("return 3 == 4;"));
assertEquals(true, exec("double x = 3; float y = 3; return x == y;"));
assertEquals(true, exec("return 3 != 4;"));
assertEquals(false, exec("double x = 3; float y = 3; return x != y;"));
}
/**
* Test boxed objects in various places
*/
public void testBoxing() {
// return
assertEquals(4, exec("return input.get(\"x\");", Collections.singletonMap("x", 4)));
// assignment
assertEquals(4, exec("int y = (Integer)input.get(\"x\"); return y;", Collections.singletonMap("x", 4)));
// comparison
assertEquals(true, exec("return 5 > (Integer)input.get(\"x\");", Collections.singletonMap("x", 4)));
}
public void testBool() {
assertEquals(true, exec("return true && true;"));
assertEquals(false, exec("boolean a = true, b = false; return a && b;"));
assertEquals(true, exec("return true || true;"));
assertEquals(true, exec("boolean a = true, b = false; return a || b;"));
}
public void testConditional() {
assertEquals(1, exec("int x = 5; return x > 3 ? 1 : 0;"));
assertEquals(0, exec("String a = null; return a != null ? 1 : 0;"));
}
public void testPrecedence() {
assertEquals(2, exec("int x = 5; return (x+x)/x;"));
assertEquals(true, exec("boolean t = true, f = false; return t && (f || t);"));
}
}

178
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/BasicStatementTests.java Normal file
View File

@ -0,0 +1,178 @@
package org.elasticsearch.plan.a;
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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.
*/
import java.util.HashMap;
import java.util.Map;
public class BasicStatementTests extends ScriptTestCase {
public void testIfStatement() {
assertEquals(1, exec("int x = 5; if (x == 5) return 1; return 0;"));
assertEquals(0, exec("int x = 4; if (x == 5) return 1; else return 0;"));
assertEquals(2, exec("int x = 4; if (x == 5) return 1; else if (x == 4) return 2; else return 0;"));
assertEquals(1, exec("int x = 4; if (x == 5) return 1; else if (x == 4) return 1; else return 0;"));
assertEquals(3, exec(
"int x = 5;\n" +
"if (x == 5) {\n" +
" int y = 2;\n" +
" \n" +
" if (y == 2) {\n" +
" x = 3;\n" +
" }\n" +
" \n" +
"}\n" +
"\n" +
"return x;\n"));
}
public void testWhileStatement() {
assertEquals("aaaaaa", exec("String c = \"a\"; int x; while (x < 5) { c += \"a\"; ++x; } return c;"));
Object value = exec(
" byte[][] b = new byte[5][5]; \n" +
" byte x = 0, y; \n" +
" \n" +
" while (x < 5) { \n" +
" y = 0; \n" +
" \n" +
" while (y < 5) { \n" +
" b[x][y] = (byte)(x*y); \n" +
" ++y; \n" +
" } \n" +
" \n" +
" ++x; \n" +
" } \n" +
" \n" +
" return b; \n");
byte[][] b = (byte[][])value;
for (byte x = 0; x < 5; ++x) {
for (byte y = 0; y < 5; ++y) {
assertEquals(x*y, b[x][y]);
}
}
}
public void testDoWhileStatement() {
assertEquals("aaaaaa", exec("String c = \"a\"; int x; do { c += \"a\"; ++x; } while (x < 5); return c;"));
Object value = exec(
" int[][] b = new int[5][5]; \n" +
" int x = 0, y; \n" +
" \n" +
" do { \n" +
" y = 0; \n" +
" \n" +
" do { \n" +
" b[x][y] = x*y; \n" +
" ++y; \n" +
" } while (y < 5); \n" +
" \n" +
" ++x; \n" +
" } while (x < 5); \n" +
" \n" +
" return b; \n");
int[][] b = (int[][])value;
for (byte x = 0; x < 5; ++x) {
for (byte y = 0; y < 5; ++y) {
assertEquals(x*y, b[x][y]);
}
}
}
public void testForStatement() {
assertEquals("aaaaaa", exec("String c = \"a\"; for (int x = 0; x < 5; ++x) c += \"a\"; return c;"));
Object value = exec(
" int[][] b = new int[5][5]; \n" +
" for (int x = 0; x < 5; ++x) { \n" +
" for (int y = 0; y < 5; ++y) { \n" +
" b[x][y] = x*y; \n" +
" } \n" +
" } \n" +
" \n" +
" return b; \n");
int[][] b = (int[][])value;
for (byte x = 0; x < 5; ++x) {
for (byte y = 0; y < 5; ++y) {
assertEquals(x*y, b[x][y]);
}
}
}
public void testDeclarationStatement() {
assertEquals((byte)2, exec("byte a = 2; return a;"));
assertEquals((short)2, exec("short a = 2; return a;"));
assertEquals((char)2, exec("char a = 2; return a;"));
assertEquals(2, exec("int a = 2; return a;"));
assertEquals(2L, exec("long a = 2; return a;"));
assertEquals(2F, exec("float a = 2; return a;"));
assertEquals(2.0, exec("double a = 2; return a;"));
assertEquals(false, exec("boolean a = false; return a;"));
assertEquals("string", exec("String a = \"string\"; return a;"));
assertEquals(HashMap.class, exec("Map<String,Object> a = new HashMap<String,Object>(); return a;").getClass());
assertEquals(byte[].class, exec("byte[] a = new byte[1]; return a;").getClass());
assertEquals(short[].class, exec("short[] a = new short[1]; return a;").getClass());
assertEquals(char[].class, exec("char[] a = new char[1]; return a;").getClass());
assertEquals(int[].class, exec("int[] a = new int[1]; return a;").getClass());
assertEquals(long[].class, exec("long[] a = new long[1]; return a;").getClass());
assertEquals(float[].class, exec("float[] a = new float[1]; return a;").getClass());
assertEquals(double[].class, exec("double[] a = new double[1]; return a;").getClass());
assertEquals(boolean[].class, exec("boolean[] a = new boolean[1]; return a;").getClass());
assertEquals(String[].class, exec("String[] a = new String[1]; return a;").getClass());
assertEquals(Map[].class, exec("Map<String,Object>[] a = new Map<String,Object>[1]; return a;").getClass());
assertEquals(byte[][].class, exec("byte[][] a = new byte[1][2]; return a;").getClass());
assertEquals(short[][][].class, exec("short[][][] a = new short[1][2][3]; return a;").getClass());
assertEquals(char[][][][].class, exec("char[][][][] a = new char[1][2][3][4]; return a;").getClass());
assertEquals(int[][][][][].class, exec("int[][][][][] a = new int[1][2][3][4][5]; return a;").getClass());
assertEquals(long[][].class, exec("long[][] a = new long[1][2]; return a;").getClass());
assertEquals(float[][][].class, exec("float[][][] a = new float[1][2][3]; return a;").getClass());
assertEquals(double[][][][].class, exec("double[][][][] a = new double[1][2][3][4]; return a;").getClass());
assertEquals(boolean[][][][][].class, exec("boolean[][][][][] a = new boolean[1][2][3][4][5]; return a;").getClass());
assertEquals(String[][].class, exec("String[][] a = new String[1][2]; return a;").getClass());
assertEquals(Map[][][].class, exec("Map<String,Object>[][][] a = new Map<String,Object>[1][2][3]; return a;").getClass());
}
public void testContinueStatement() {
assertEquals(9, exec("int x = 0, y = 0; while (x < 10) { ++x; if (x == 1) continue; ++y; } return y;"));
}
public void testBreakStatement() {
assertEquals(4, exec("int x = 0, y = 0; while (x < 10) { ++x; if (x == 5) break; ++y; } return y;"));
}
public void testReturnStatement() {
assertEquals(10, exec("return 10;"));
assertEquals(5, exec("int x = 5; return x;"));
assertEquals(4, exec("int[] x = new int[2]; x[1] = 4; return x[1];"));
assertEquals(5, ((short[])exec("short[] s = new short[3]; s[1] = 5; return s;"))[1]);
assertEquals(10, ((Map)exec("Map<String, Object> s = new HashMap< String , Object >(); s.put(\"x\", 10); return s;")).get("x"));
}
}

294
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/BinaryOperatorTests.java Normal file
View File

@ -0,0 +1,294 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
/**
* Tests binary operators across different types
*/
// TODO: NaN/Inf/overflow/...
public class BinaryOperatorTests extends ScriptTestCase {
// TODO: move to per-type tests and test for each type
public void testBasics() {
assertEquals(2.25F / 1.5F, exec("return 2.25F / 1.5F;"));
assertEquals(2.25F % 1.5F, exec("return 2.25F % 1.5F;"));
assertEquals(2 - 1, exec("return 2 - 1;"));
assertEquals(1 << 2, exec("return 1 << 2;"));
assertEquals(4 >> 2, exec("return 4 >> 2;"));
assertEquals(-1 >>> 29, exec("return -1 >>> 29;"));
assertEquals(5 & 3, exec("return 5 & 3;"));
assertEquals(5 & 3L, exec("return 5 & 3L;"));
assertEquals(5L & 3, exec("return 5L & 3;"));
assertEquals(5 | 3, exec("return 5 | 3;"));
assertEquals(5L | 3, exec("return 5L | 3;"));
assertEquals(5 | 3L, exec("return 5 | 3L;"));
assertEquals(9 ^ 3, exec("return 9 ^ 3;"));
assertEquals(9L ^ 3, exec("return 9L ^ 3;"));
assertEquals(9 ^ 3L, exec("return 9 ^ 3L;"));
}
public void testLongShifts() {
// note: we always promote the results of shifts too (unlike java)
assertEquals(1L << 2, exec("long x = 1L; int y = 2; return x << y;"));
assertEquals(1L << 2L, exec("long x = 1L; long y = 2L; return x << y;"));
assertEquals(4L >> 2L, exec("long x = 4L; long y = 2L; return x >> y;"));
assertEquals(4L >> 2, exec("long x = 4L; int y = 2; return x >> y;"));
assertEquals(-1L >>> 29, exec("long x = -1L; int y = 29; return x >>> y;"));
assertEquals(-1L >>> 29L, exec("long x = -1L; long y = 29L; return x >>> y;"));
}
public void testLongShiftsConst() {
// note: we always promote the results of shifts too (unlike java)
assertEquals(1L << 2, exec("return 1L << 2;"));
assertEquals(1L << 2L, exec("return 1 << 2L;"));
assertEquals(4L >> 2L, exec("return 4 >> 2L;"));
assertEquals(4L >> 2, exec("return 4L >> 2;"));
assertEquals(-1L >>> 29, exec("return -1L >>> 29;"));
assertEquals(-1L >>> 29L, exec("return -1 >>> 29L;"));
}
public void testMixedTypes() {
assertEquals(8, exec("int x = 4; char y = 2; return x*y;"));
assertEquals(0.5, exec("double x = 1; float y = 2; return x / y;"));
assertEquals(1, exec("int x = 3; int y = 2; return x % y;"));
assertEquals(3.0, exec("double x = 1; byte y = 2; return x + y;"));
assertEquals(-1, exec("int x = 1; char y = 2; return x - y;"));
assertEquals(4, exec("int x = 1; char y = 2; return x << y;"));
assertEquals(-1, exec("int x = -1; char y = 29; return x >> y;"));
assertEquals(3, exec("int x = -1; char y = 30; return x >>> y;"));
assertEquals(1L, exec("int x = 5; long y = 3; return x & y;"));
assertEquals(7, exec("short x = 5; byte y = 3; return x | y;"));
assertEquals(10, exec("short x = 9; char y = 3; return x ^ y;"));
}
public void testBinaryPromotion() throws Exception {
// byte/byte
assertEquals((byte)1 + (byte)1, exec("byte x = 1; byte y = 1; return x+y;"));
// byte/char
assertEquals((byte)1 + (char)1, exec("byte x = 1; char y = 1; return x+y;"));
// byte/short
assertEquals((byte)1 + (short)1, exec("byte x = 1; short y = 1; return x+y;"));
// byte/int
assertEquals((byte)1 + 1, exec("byte x = 1; int y = 1; return x+y;"));
// byte/long
assertEquals((byte)1 + 1L, exec("byte x = 1; long y = 1; return x+y;"));
// byte/float
assertEquals((byte)1 + 1F, exec("byte x = 1; float y = 1; return x+y;"));
// byte/double
assertEquals((byte)1 + 1.0, exec("byte x = 1; double y = 1; return x+y;"));
// char/byte
assertEquals((char)1 + (byte)1, exec("char x = 1; byte y = 1; return x+y;"));
// char/char
assertEquals((char)1 + (char)1, exec("char x = 1; char y = 1; return x+y;"));
// char/short
assertEquals((char)1 + (short)1, exec("char x = 1; short y = 1; return x+y;"));
// char/int
assertEquals((char)1 + 1, exec("char x = 1; int y = 1; return x+y;"));
// char/long
assertEquals((char)1 + 1L, exec("char x = 1; long y = 1; return x+y;"));
// char/float
assertEquals((char)1 + 1F, exec("char x = 1; float y = 1; return x+y;"));
// char/double
assertEquals((char)1 + 1.0, exec("char x = 1; double y = 1; return x+y;"));
// short/byte
assertEquals((short)1 + (byte)1, exec("short x = 1; byte y = 1; return x+y;"));
// short/char
assertEquals((short)1 + (char)1, exec("short x = 1; char y = 1; return x+y;"));
// short/short
assertEquals((short)1 + (short)1, exec("short x = 1; short y = 1; return x+y;"));
// short/int
assertEquals((short)1 + 1, exec("short x = 1; int y = 1; return x+y;"));
// short/long
assertEquals((short)1 + 1L, exec("short x = 1; long y = 1; return x+y;"));
// short/float
assertEquals((short)1 + 1F, exec("short x = 1; float y = 1; return x+y;"));
// short/double
assertEquals((short)1 + 1.0, exec("short x = 1; double y = 1; return x+y;"));
// int/byte
assertEquals(1 + (byte)1, exec("int x = 1; byte y = 1; return x+y;"));
// int/char
assertEquals(1 + (char)1, exec("int x = 1; char y = 1; return x+y;"));
// int/short
assertEquals(1 + (short)1, exec("int x = 1; short y = 1; return x+y;"));
// int/int
assertEquals(1 + 1, exec("int x = 1; int y = 1; return x+y;"));
// int/long
assertEquals(1 + 1L, exec("int x = 1; long y = 1; return x+y;"));
// int/float
assertEquals(1 + 1F, exec("int x = 1; float y = 1; return x+y;"));
// int/double
assertEquals(1 + 1.0, exec("int x = 1; double y = 1; return x+y;"));
// long/byte
assertEquals(1L + (byte)1, exec("long x = 1; byte y = 1; return x+y;"));
// long/char
assertEquals(1L + (char)1, exec("long x = 1; char y = 1; return x+y;"));
// long/short
assertEquals(1L + (short)1, exec("long x = 1; short y = 1; return x+y;"));
// long/int
assertEquals(1L + 1, exec("long x = 1; int y = 1; return x+y;"));
// long/long
assertEquals(1L + 1L, exec("long x = 1; long y = 1; return x+y;"));
// long/float
assertEquals(1L + 1F, exec("long x = 1; float y = 1; return x+y;"));
// long/double
assertEquals(1L + 1.0, exec("long x = 1; double y = 1; return x+y;"));
// float/byte
assertEquals(1F + (byte)1, exec("float x = 1; byte y = 1; return x+y;"));
// float/char
assertEquals(1F + (char)1, exec("float x = 1; char y = 1; return x+y;"));
// float/short
assertEquals(1F + (short)1, exec("float x = 1; short y = 1; return x+y;"));
// float/int
assertEquals(1F + 1, exec("float x = 1; int y = 1; return x+y;"));
// float/long
assertEquals(1F + 1L, exec("float x = 1; long y = 1; return x+y;"));
// float/float
assertEquals(1F + 1F, exec("float x = 1; float y = 1; return x+y;"));
// float/double
assertEquals(1F + 1.0, exec("float x = 1; double y = 1; return x+y;"));
// double/byte
assertEquals(1.0 + (byte)1, exec("double x = 1; byte y = 1; return x+y;"));
// double/char
assertEquals(1.0 + (char)1, exec("double x = 1; char y = 1; return x+y;"));
// double/short
assertEquals(1.0 + (short)1, exec("double x = 1; short y = 1; return x+y;"));
// double/int
assertEquals(1.0 + 1, exec("double x = 1; int y = 1; return x+y;"));
// double/long
assertEquals(1.0 + 1L, exec("double x = 1; long y = 1; return x+y;"));
// double/float
assertEquals(1.0 + 1F, exec("double x = 1; float y = 1; return x+y;"));
// double/double
assertEquals(1.0 + 1.0, exec("double x = 1; double y = 1; return x+y;"));
}
public void testBinaryPromotionConst() throws Exception {
// byte/byte
assertEquals((byte)1 + (byte)1, exec("return (byte)1 + (byte)1;"));
// byte/char
assertEquals((byte)1 + (char)1, exec("return (byte)1 + (char)1;"));
// byte/short
assertEquals((byte)1 + (short)1, exec("return (byte)1 + (short)1;"));
// byte/int
assertEquals((byte)1 + 1, exec("return (byte)1 + 1;"));
// byte/long
assertEquals((byte)1 + 1L, exec("return (byte)1 + 1L;"));
// byte/float
assertEquals((byte)1 + 1F, exec("return (byte)1 + 1F;"));
// byte/double
assertEquals((byte)1 + 1.0, exec("return (byte)1 + 1.0;"));
// char/byte
assertEquals((char)1 + (byte)1, exec("return (char)1 + (byte)1;"));
// char/char
assertEquals((char)1 + (char)1, exec("return (char)1 + (char)1;"));
// char/short
assertEquals((char)1 + (short)1, exec("return (char)1 + (short)1;"));
// char/int
assertEquals((char)1 + 1, exec("return (char)1 + 1;"));
// char/long
assertEquals((char)1 + 1L, exec("return (char)1 + 1L;"));
// char/float
assertEquals((char)1 + 1F, exec("return (char)1 + 1F;"));
// char/double
assertEquals((char)1 + 1.0, exec("return (char)1 + 1.0;"));
// short/byte
assertEquals((short)1 + (byte)1, exec("return (short)1 + (byte)1;"));
// short/char
assertEquals((short)1 + (char)1, exec("return (short)1 + (char)1;"));
// short/short
assertEquals((short)1 + (short)1, exec("return (short)1 + (short)1;"));
// short/int
assertEquals((short)1 + 1, exec("return (short)1 + 1;"));
// short/long
assertEquals((short)1 + 1L, exec("return (short)1 + 1L;"));
// short/float
assertEquals((short)1 + 1F, exec("return (short)1 + 1F;"));
// short/double
assertEquals((short)1 + 1.0, exec("return (short)1 + 1.0;"));
// int/byte
assertEquals(1 + (byte)1, exec("return 1 + (byte)1;"));
// int/char
assertEquals(1 + (char)1, exec("return 1 + (char)1;"));
// int/short
assertEquals(1 + (short)1, exec("return 1 + (short)1;"));
// int/int
assertEquals(1 + 1, exec("return 1 + 1;"));
// int/long
assertEquals(1 + 1L, exec("return 1 + 1L;"));
// int/float
assertEquals(1 + 1F, exec("return 1 + 1F;"));
// int/double
assertEquals(1 + 1.0, exec("return 1 + 1.0;"));
// long/byte
assertEquals(1L + (byte)1, exec("return 1L + (byte)1;"));
// long/char
assertEquals(1L + (char)1, exec("return 1L + (char)1;"));
// long/short
assertEquals(1L + (short)1, exec("return 1L + (short)1;"));
// long/int
assertEquals(1L + 1, exec("return 1L + 1;"));
// long/long
assertEquals(1L + 1L, exec("return 1L + 1L;"));
// long/float
assertEquals(1L + 1F, exec("return 1L + 1F;"));
// long/double
assertEquals(1L + 1.0, exec("return 1L + 1.0;"));
// float/byte
assertEquals(1F + (byte)1, exec("return 1F + (byte)1;"));
// float/char
assertEquals(1F + (char)1, exec("return 1F + (char)1;"));
// float/short
assertEquals(1F + (short)1, exec("return 1F + (short)1;"));
// float/int
assertEquals(1F + 1, exec("return 1F + 1;"));
// float/long
assertEquals(1F + 1L, exec("return 1F + 1L;"));
// float/float
assertEquals(1F + 1F, exec("return 1F + 1F;"));
// float/double
assertEquals(1F + 1.0, exec("return 1F + 1.0;"));
// double/byte
assertEquals(1.0 + (byte)1, exec("return 1.0 + (byte)1;"));
// double/char
assertEquals(1.0 + (char)1, exec("return 1.0 + (char)1;"));
// double/short
assertEquals(1.0 + (short)1, exec("return 1.0 + (short)1;"));
// double/int
assertEquals(1.0 + 1, exec("return 1.0 + 1;"));
// double/long
assertEquals(1.0 + 1L, exec("return 1.0 + 1L;"));
// double/float
assertEquals(1.0 + 1F, exec("return 1.0 + 1F;"));
// double/double
assertEquals(1.0 + 1.0, exec("return 1.0 + 1.0;"));
}
}

319
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/CompoundAssignmentTests.java Normal file
View File

@ -0,0 +1,319 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
/**
* Tests compound assignments (+=, etc) across all data types
*/
public class CompoundAssignmentTests extends ScriptTestCase {
public void testAddition() {
// byte
assertEquals((byte) 15, exec("byte x = 5; x += 10; return x;"));
assertEquals((byte) -5, exec("byte x = 5; x += -10; return x;"));
// short
assertEquals((short) 15, exec("short x = 5; x += 10; return x;"));
assertEquals((short) -5, exec("short x = 5; x += -10; return x;"));
// char
assertEquals((char) 15, exec("char x = 5; x += 10; return x;"));
assertEquals((char) 5, exec("char x = 10; x += -5; return x;"));
// int
assertEquals(15, exec("int x = 5; x += 10; return x;"));
assertEquals(-5, exec("int x = 5; x += -10; return x;"));
// long
assertEquals(15L, exec("long x = 5; x += 10; return x;"));
assertEquals(-5L, exec("long x = 5; x += -10; return x;"));
// float
assertEquals(15F, exec("float x = 5f; x += 10; return x;"));
assertEquals(-5F, exec("float x = 5f; x += -10; return x;"));
// double
assertEquals(15D, exec("double x = 5.0; x += 10; return x;"));
assertEquals(-5D, exec("double x = 5.0; x += -10; return x;"));
}
public void testSubtraction() {
// byte
assertEquals((byte) 15, exec("byte x = 5; x -= -10; return x;"));
assertEquals((byte) -5, exec("byte x = 5; x -= 10; return x;"));
// short
assertEquals((short) 15, exec("short x = 5; x -= -10; return x;"));
assertEquals((short) -5, exec("short x = 5; x -= 10; return x;"));
// char
assertEquals((char) 15, exec("char x = 5; x -= -10; return x;"));
assertEquals((char) 5, exec("char x = 10; x -= 5; return x;"));
// int
assertEquals(15, exec("int x = 5; x -= -10; return x;"));
assertEquals(-5, exec("int x = 5; x -= 10; return x;"));
// long
assertEquals(15L, exec("long x = 5; x -= -10; return x;"));
assertEquals(-5L, exec("long x = 5; x -= 10; return x;"));
// float
assertEquals(15F, exec("float x = 5f; x -= -10; return x;"));
assertEquals(-5F, exec("float x = 5f; x -= 10; return x;"));
// double
assertEquals(15D, exec("double x = 5.0; x -= -10; return x;"));
assertEquals(-5D, exec("double x = 5.0; x -= 10; return x;"));
}
public void testMultiplication() {
// byte
assertEquals((byte) 15, exec("byte x = 5; x *= 3; return x;"));
assertEquals((byte) -5, exec("byte x = 5; x *= -1; return x;"));
// short
assertEquals((short) 15, exec("short x = 5; x *= 3; return x;"));
assertEquals((short) -5, exec("short x = 5; x *= -1; return x;"));
// char
assertEquals((char) 15, exec("char x = 5; x *= 3; return x;"));
// int
assertEquals(15, exec("int x = 5; x *= 3; return x;"));
assertEquals(-5, exec("int x = 5; x *= -1; return x;"));
// long
assertEquals(15L, exec("long x = 5; x *= 3; return x;"));
assertEquals(-5L, exec("long x = 5; x *= -1; return x;"));
// float
assertEquals(15F, exec("float x = 5f; x *= 3; return x;"));
assertEquals(-5F, exec("float x = 5f; x *= -1; return x;"));
// double
assertEquals(15D, exec("double x = 5.0; x *= 3; return x;"));
assertEquals(-5D, exec("double x = 5.0; x *= -1; return x;"));
}
public void testDivision() {
// byte
assertEquals((byte) 15, exec("byte x = 45; x /= 3; return x;"));
assertEquals((byte) -5, exec("byte x = 5; x /= -1; return x;"));
// short
assertEquals((short) 15, exec("short x = 45; x /= 3; return x;"));
assertEquals((short) -5, exec("short x = 5; x /= -1; return x;"));
// char
assertEquals((char) 15, exec("char x = 45; x /= 3; return x;"));
// int
assertEquals(15, exec("int x = 45; x /= 3; return x;"));
assertEquals(-5, exec("int x = 5; x /= -1; return x;"));
// long
assertEquals(15L, exec("long x = 45; x /= 3; return x;"));
assertEquals(-5L, exec("long x = 5; x /= -1; return x;"));
// float
assertEquals(15F, exec("float x = 45f; x /= 3; return x;"));
assertEquals(-5F, exec("float x = 5f; x /= -1; return x;"));
// double
assertEquals(15D, exec("double x = 45.0; x /= 3; return x;"));
assertEquals(-5D, exec("double x = 5.0; x /= -1; return x;"));
}
public void testDivisionByZero() {
// byte
try {
exec("byte x = 1; x /= 0; return x;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
// short
try {
exec("short x = 1; x /= 0; return x;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
// char
try {
exec("char x = 1; x /= 0; return x;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
// int
try {
exec("int x = 1; x /= 0; return x;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
// long
try {
exec("long x = 1; x /= 0; return x;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
}
public void testRemainder() {
// byte
assertEquals((byte) 3, exec("byte x = 15; x %= 4; return x;"));
assertEquals((byte) -3, exec("byte x = (byte) -15; x %= 4; return x;"));
// short
assertEquals((short) 3, exec("short x = 15; x %= 4; return x;"));
assertEquals((short) -3, exec("short x = (short) -15; x %= 4; return x;"));
// char
assertEquals((char) 3, exec("char x = (char) 15; x %= 4; return x;"));
// int
assertEquals(3, exec("int x = 15; x %= 4; return x;"));
assertEquals(-3, exec("int x = -15; x %= 4; return x;"));
// long
assertEquals(3L, exec("long x = 15L; x %= 4; return x;"));
assertEquals(-3L, exec("long x = -15L; x %= 4; return x;"));
// float
assertEquals(3F, exec("float x = 15F; x %= 4; return x;"));
assertEquals(-3F, exec("float x = -15F; x %= 4; return x;"));
// double
assertEquals(3D, exec("double x = 15.0; x %= 4; return x;"));
assertEquals(-3D, exec("double x = -15.0; x %= 4; return x;"));
}
public void testLeftShift() {
// byte
assertEquals((byte) 60, exec("byte x = 15; x <<= 2; return x;"));
assertEquals((byte) -60, exec("byte x = (byte) -15; x <<= 2; return x;"));
// short
assertEquals((short) 60, exec("short x = 15; x <<= 2; return x;"));
assertEquals((short) -60, exec("short x = (short) -15; x <<= 2; return x;"));
// char
assertEquals((char) 60, exec("char x = (char) 15; x <<= 2; return x;"));
// int
assertEquals(60, exec("int x = 15; x <<= 2; return x;"));
assertEquals(-60, exec("int x = -15; x <<= 2; return x;"));
// long
assertEquals(60L, exec("long x = 15L; x <<= 2; return x;"));
assertEquals(-60L, exec("long x = -15L; x <<= 2; return x;"));
}
public void testRightShift() {
// byte
assertEquals((byte) 15, exec("byte x = 60; x >>= 2; return x;"));
assertEquals((byte) -15, exec("byte x = (byte) -60; x >>= 2; return x;"));
// short
assertEquals((short) 15, exec("short x = 60; x >>= 2; return x;"));
assertEquals((short) -15, exec("short x = (short) -60; x >>= 2; return x;"));
// char
assertEquals((char) 15, exec("char x = (char) 60; x >>= 2; return x;"));
// int
assertEquals(15, exec("int x = 60; x >>= 2; return x;"));
assertEquals(-15, exec("int x = -60; x >>= 2; return x;"));
// long
assertEquals(15L, exec("long x = 60L; x >>= 2; return x;"));
assertEquals(-15L, exec("long x = -60L; x >>= 2; return x;"));
}
public void testUnsignedRightShift() {
// byte
assertEquals((byte) 15, exec("byte x = 60; x >>>= 2; return x;"));
assertEquals((byte) -15, exec("byte x = (byte) -60; x >>>= 2; return x;"));
// short
assertEquals((short) 15, exec("short x = 60; x >>>= 2; return x;"));
assertEquals((short) -15, exec("short x = (short) -60; x >>>= 2; return x;"));
// char
assertEquals((char) 15, exec("char x = (char) 60; x >>>= 2; return x;"));
// int
assertEquals(15, exec("int x = 60; x >>>= 2; return x;"));
assertEquals(-60 >>> 2, exec("int x = -60; x >>>= 2; return x;"));
// long
assertEquals(15L, exec("long x = 60L; x >>>= 2; return x;"));
assertEquals(-60L >>> 2, exec("long x = -60L; x >>>= 2; return x;"));
}
public void testAnd() {
// boolean
assertEquals(true, exec("boolean x = true; x &= true; return x;"));
assertEquals(false, exec("boolean x = true; x &= false; return x;"));
assertEquals(false, exec("boolean x = false; x &= true; return x;"));
assertEquals(false, exec("boolean x = false; x &= false; return x;"));
assertEquals(true, exec("Boolean x = true; x &= true; return x;"));
assertEquals(false, exec("Boolean x = true; x &= false; return x;"));
assertEquals(false, exec("Boolean x = false; x &= true; return x;"));
assertEquals(false, exec("Boolean x = false; x &= false; return x;"));
assertEquals(true, exec("boolean[] x = new boolean[1]; x[0] = true; x[0] &= true; return x[0];"));
assertEquals(false, exec("boolean[] x = new boolean[1]; x[0] = true; x[0] &= false; return x[0];"));
assertEquals(false, exec("boolean[] x = new boolean[1]; x[0] = false; x[0] &= true; return x[0];"));
assertEquals(false, exec("boolean[] x = new boolean[1]; x[0] = false; x[0] &= false; return x[0];"));
assertEquals(true, exec("Boolean[] x = new Boolean[1]; x[0] = true; x[0] &= true; return x[0];"));
assertEquals(false, exec("Boolean[] x = new Boolean[1]; x[0] = true; x[0] &= false; return x[0];"));
assertEquals(false, exec("Boolean[] x = new Boolean[1]; x[0] = false; x[0] &= true; return x[0];"));
assertEquals(false, exec("Boolean[] x = new Boolean[1]; x[0] = false; x[0] &= false; return x[0];"));
// byte
assertEquals((byte) (13 & 14), exec("byte x = 13; x &= 14; return x;"));
// short
assertEquals((short) (13 & 14), exec("short x = 13; x &= 14; return x;"));
// char
assertEquals((char) (13 & 14), exec("char x = 13; x &= 14; return x;"));
// int
assertEquals(13 & 14, exec("int x = 13; x &= 14; return x;"));
// long
assertEquals((long) (13 & 14), exec("long x = 13L; x &= 14; return x;"));
}
public void testOr() {
// boolean
assertEquals(true, exec("boolean x = true; x |= true; return x;"));
assertEquals(true, exec("boolean x = true; x |= false; return x;"));
assertEquals(true, exec("boolean x = false; x |= true; return x;"));
assertEquals(false, exec("boolean x = false; x |= false; return x;"));
assertEquals(true, exec("Boolean x = true; x |= true; return x;"));
assertEquals(true, exec("Boolean x = true; x |= false; return x;"));
assertEquals(true, exec("Boolean x = false; x |= true; return x;"));
assertEquals(false, exec("Boolean x = false; x |= false; return x;"));
assertEquals(true, exec("boolean[] x = new boolean[1]; x[0] = true; x[0] |= true; return x[0];"));
assertEquals(true, exec("boolean[] x = new boolean[1]; x[0] = true; x[0] |= false; return x[0];"));
assertEquals(true, exec("boolean[] x = new boolean[1]; x[0] = false; x[0] |= true; return x[0];"));
assertEquals(false, exec("boolean[] x = new boolean[1]; x[0] = false; x[0] |= false; return x[0];"));
assertEquals(true, exec("Boolean[] x = new Boolean[1]; x[0] = true; x[0] |= true; return x[0];"));
assertEquals(true, exec("Boolean[] x = new Boolean[1]; x[0] = true; x[0] |= false; return x[0];"));
assertEquals(true, exec("Boolean[] x = new Boolean[1]; x[0] = false; x[0] |= true; return x[0];"));
assertEquals(false, exec("Boolean[] x = new Boolean[1]; x[0] = false; x[0] |= false; return x[0];"));
// byte
assertEquals((byte) (13 | 14), exec("byte x = 13; x |= 14; return x;"));
// short
assertEquals((short) (13 | 14), exec("short x = 13; x |= 14; return x;"));
// char
assertEquals((char) (13 | 14), exec("char x = 13; x |= 14; return x;"));
// int
assertEquals(13 | 14, exec("int x = 13; x |= 14; return x;"));
// long
assertEquals((long) (13 | 14), exec("long x = 13L; x |= 14; return x;"));
}
public void testXor() {
// boolean
assertEquals(false, exec("boolean x = true; x ^= true; return x;"));
assertEquals(true, exec("boolean x = true; x ^= false; return x;"));
assertEquals(true, exec("boolean x = false; x ^= true; return x;"));
assertEquals(false, exec("boolean x = false; x ^= false; return x;"));
assertEquals(false, exec("Boolean x = true; x ^= true; return x;"));
assertEquals(true, exec("Boolean x = true; x ^= false; return x;"));
assertEquals(true, exec("Boolean x = false; x ^= true; return x;"));
assertEquals(false, exec("Boolean x = false; x ^= false; return x;"));
assertEquals(false, exec("boolean[] x = new boolean[1]; x[0] = true; x[0] ^= true; return x[0];"));
assertEquals(true, exec("boolean[] x = new boolean[1]; x[0] = true; x[0] ^= false; return x[0];"));
assertEquals(true, exec("boolean[] x = new boolean[1]; x[0] = false; x[0] ^= true; return x[0];"));
assertEquals(false, exec("boolean[] x = new boolean[1]; x[0] = false; x[0] ^= false; return x[0];"));
assertEquals(false, exec("Boolean[] x = new Boolean[1]; x[0] = true; x[0] ^= true; return x[0];"));
assertEquals(true, exec("Boolean[] x = new Boolean[1]; x[0] = true; x[0] ^= false; return x[0];"));
assertEquals(true, exec("Boolean[] x = new Boolean[1]; x[0] = false; x[0] ^= true; return x[0];"));
assertEquals(false, exec("Boolean[] x = new Boolean[1]; x[0] = false; x[0] ^= false; return x[0];"));
// byte
assertEquals((byte) (13 ^ 14), exec("byte x = 13; x ^= 14; return x;"));
// short
assertEquals((short) (13 ^ 14), exec("short x = 13; x ^= 14; return x;"));
// char
assertEquals((char) (13 ^ 14), exec("char x = 13; x ^= 14; return x;"));
// int
assertEquals(13 ^ 14, exec("int x = 13; x ^= 14; return x;"));
// long
assertEquals((long) (13 ^ 14), exec("long x = 13L; x ^= 14; return x;"));
}
}

93
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/ConditionalTests.java Normal file
View File

@ -0,0 +1,93 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import java.util.ArrayList;
import java.util.HashMap;
public class ConditionalTests extends ScriptTestCase {
public void testBasic() {
assertEquals(2, exec("boolean x = true; return x ? 2 : 3;"));
assertEquals(3, exec("boolean x = false; return x ? 2 : 3;"));
assertEquals(3, exec("boolean x = false, y = true; return x && y ? 2 : 3;"));
assertEquals(2, exec("boolean x = true, y = true; return x && y ? 2 : 3;"));
assertEquals(2, exec("boolean x = true, y = false; return x || y ? 2 : 3;"));
assertEquals(3, exec("boolean x = false, y = false; return x || y ? 2 : 3;"));
}
public void testPrecedence() {
assertEquals(4, exec("boolean x = false, y = true; return x ? (y ? 2 : 3) : 4;"));
assertEquals(2, exec("boolean x = true, y = true; return x ? (y ? 2 : 3) : 4;"));
assertEquals(3, exec("boolean x = true, y = false; return x ? (y ? 2 : 3) : 4;"));
assertEquals(2, exec("boolean x = true, y = true; return x ? y ? 2 : 3 : 4;"));
assertEquals(4, exec("boolean x = false, y = true; return x ? y ? 2 : 3 : 4;"));
assertEquals(3, exec("boolean x = true, y = false; return x ? y ? 2 : 3 : 4;"));
assertEquals(3, exec("boolean x = false, y = true; return x ? 2 : y ? 3 : 4;"));
assertEquals(2, exec("boolean x = true, y = false; return x ? 2 : y ? 3 : 4;"));
assertEquals(4, exec("boolean x = false, y = false; return x ? 2 : y ? 3 : 4;"));
assertEquals(4, exec("boolean x = false, y = false; return (x ? true : y) ? 3 : 4;"));
assertEquals(4, exec("boolean x = true, y = false; return (x ? false : y) ? 3 : 4;"));
assertEquals(3, exec("boolean x = false, y = true; return (x ? false : y) ? 3 : 4;"));
assertEquals(2, exec("boolean x = true, y = false; return (x ? false : y) ? (x ? 3 : 4) : x ? 2 : 1;"));
assertEquals(2, exec("boolean x = true, y = false; return (x ? false : y) ? x ? 3 : 4 : x ? 2 : 1;"));
assertEquals(4, exec("boolean x = false, y = true; return x ? false : y ? x ? 3 : 4 : x ? 2 : 1;"));
}
public void testAssignment() {
assertEquals(4D, exec("boolean x = false; double z = x ? 2 : 4.0F; return z;"));
assertEquals((byte)7, exec("boolean x = false; int y = 2; byte z = x ? (byte)y : 7; return z;"));
assertEquals((byte)7, exec("boolean x = false; int y = 2; byte z = (byte)(x ? y : 7); return z;"));
assertEquals(ArrayList.class, exec("boolean x = false; Object z = x ? new HashMap() : new ArrayList(); return z;").getClass());
}
public void testNullArguments() {
assertEquals(null, exec("boolean b = false, c = true; Object x; Map y; return b && c ? x : y;"));
assertEquals(HashMap.class, exec("boolean b = false, c = true; Object x; Map y = new HashMap(); return b && c ? x : y;").getClass());
}
public void testPromotion() {
assertEquals(false, exec("boolean x = false; boolean y = true; return (x ? 2 : 4.0F) == (y ? 2 : 4.0F);"));
assertEquals(false, exec("boolean x = false; boolean y = true; return (x ? 2 : 4.0F) == (y ? new Long(2) : new Float(4.0F));"));
assertEquals(false, exec("boolean x = false; boolean y = true; return (x ? new HashMap() : new ArrayList()) == (y ? new Long(2) : new Float(4.0F));"));
assertEquals(false, exec("boolean x = false; boolean y = true; return (x ? 2 : 4.0F) == (y ? new HashMap() : new ArrayList());"));
}
public void testIncompatibleAssignment() {
try {
exec("boolean x = false; byte z = x ? 2 : 4.0F; return z;");
fail("expected class cast exception");
} catch (ClassCastException expected) {}
try {
exec("boolean x = false; Map z = x ? 4 : (byte)7; return z;");
fail("expected class cast exception");
} catch (ClassCastException expected) {}
try {
exec("boolean x = false; Map z = x ? new HashMap() : new ArrayList(); return z;");
fail("expected class cast exception");
} catch (ClassCastException expected) {}
try {
exec("boolean x = false; int y = 2; byte z = x ? y : 7; return z;");
fail("expected class cast exception");
} catch (ClassCastException expected) {}
}
}

914
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/DefTests.java Normal file
View File

@ -0,0 +1,914 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
public class DefTests extends ScriptTestCase {
public void testNot() {
assertEquals(~1, exec("def x = (byte)1 return ~x"));
assertEquals(~1, exec("def x = (short)1 return ~x"));
assertEquals(~1, exec("def x = (char)1 return ~x"));
assertEquals(~1, exec("def x = 1 return ~x"));
assertEquals(~1L, exec("def x = 1L return ~x"));
}
public void testNeg() {
assertEquals(-1, exec("def x = (byte)1 return -x"));
assertEquals(-1, exec("def x = (short)1 return -x"));
assertEquals(-1, exec("def x = (char)1 return -x"));
assertEquals(-1, exec("def x = 1 return -x"));
assertEquals(-1L, exec("def x = 1L return -x"));
assertEquals(-1.0F, exec("def x = 1F return -x"));
assertEquals(-1.0, exec("def x = 1.0 return -x"));
}
public void testMul() {
assertEquals(4, exec("def x = (byte)2 def y = (byte)2 return x * y"));
assertEquals(4, exec("def x = (short)2 def y = (byte)2 return x * y"));
assertEquals(4, exec("def x = (char)2 def y = (byte)2 return x * y"));
assertEquals(4, exec("def x = (int)2 def y = (byte)2 return x * y"));
assertEquals(4L, exec("def x = (long)2 def y = (byte)2 return x * y"));
assertEquals(4F, exec("def x = (float)2 def y = (byte)2 return x * y"));
assertEquals(4D, exec("def x = (double)2 def y = (byte)2 return x * y"));
assertEquals(4, exec("def x = (byte)2 def y = (short)2 return x * y"));
assertEquals(4, exec("def x = (short)2 def y = (short)2 return x * y"));
assertEquals(4, exec("def x = (char)2 def y = (short)2 return x * y"));
assertEquals(4, exec("def x = (int)2 def y = (short)2 return x * y"));
assertEquals(4L, exec("def x = (long)2 def y = (short)2 return x * y"));
assertEquals(4F, exec("def x = (float)2 def y = (short)2 return x * y"));
assertEquals(4D, exec("def x = (double)2 def y = (short)2 return x * y"));
assertEquals(4, exec("def x = (byte)2 def y = (char)2 return x * y"));
assertEquals(4, exec("def x = (short)2 def y = (char)2 return x * y"));
assertEquals(4, exec("def x = (char)2 def y = (char)2 return x * y"));
assertEquals(4, exec("def x = (int)2 def y = (char)2 return x * y"));
assertEquals(4L, exec("def x = (long)2 def y = (char)2 return x * y"));
assertEquals(4F, exec("def x = (float)2 def y = (char)2 return x * y"));
assertEquals(4D, exec("def x = (double)2 def y = (char)2 return x * y"));
assertEquals(4, exec("def x = (byte)2 def y = (int)2 return x * y"));
assertEquals(4, exec("def x = (short)2 def y = (int)2 return x * y"));
assertEquals(4, exec("def x = (char)2 def y = (int)2 return x * y"));
assertEquals(4, exec("def x = (int)2 def y = (int)2 return x * y"));
assertEquals(4L, exec("def x = (long)2 def y = (int)2 return x * y"));
assertEquals(4F, exec("def x = (float)2 def y = (int)2 return x * y"));
assertEquals(4D, exec("def x = (double)2 def y = (int)2 return x * y"));
assertEquals(4L, exec("def x = (byte)2 def y = (long)2 return x * y"));
assertEquals(4L, exec("def x = (short)2 def y = (long)2 return x * y"));
assertEquals(4L, exec("def x = (char)2 def y = (long)2 return x * y"));
assertEquals(4L, exec("def x = (int)2 def y = (long)2 return x * y"));
assertEquals(4L, exec("def x = (long)2 def y = (long)2 return x * y"));
assertEquals(4F, exec("def x = (float)2 def y = (long)2 return x * y"));
assertEquals(4D, exec("def x = (double)2 def y = (long)2 return x * y"));
assertEquals(4F, exec("def x = (byte)2 def y = (float)2 return x * y"));
assertEquals(4F, exec("def x = (short)2 def y = (float)2 return x * y"));
assertEquals(4F, exec("def x = (char)2 def y = (float)2 return x * y"));
assertEquals(4F, exec("def x = (int)2 def y = (float)2 return x * y"));
assertEquals(4F, exec("def x = (long)2 def y = (float)2 return x * y"));
assertEquals(4F, exec("def x = (float)2 def y = (float)2 return x * y"));
assertEquals(4D, exec("def x = (double)2 def y = (float)2 return x * y"));
assertEquals(4D, exec("def x = (byte)2 def y = (double)2 return x * y"));
assertEquals(4D, exec("def x = (short)2 def y = (double)2 return x * y"));
assertEquals(4D, exec("def x = (char)2 def y = (double)2 return x * y"));
assertEquals(4D, exec("def x = (int)2 def y = (double)2 return x * y"));
assertEquals(4D, exec("def x = (long)2 def y = (double)2 return x * y"));
assertEquals(4D, exec("def x = (float)2 def y = (double)2 return x * y"));
assertEquals(4D, exec("def x = (double)2 def y = (double)2 return x * y"));
assertEquals(4, exec("def x = (Byte)2 def y = (byte)2 return x * y"));
assertEquals(4, exec("def x = (Short)2 def y = (short)2 return x * y"));
assertEquals(4, exec("def x = (Character)2 def y = (char)2 return x * y"));
assertEquals(4, exec("def x = (Integer)2 def y = (int)2 return x * y"));
assertEquals(4L, exec("def x = (Long)2 def y = (long)2 return x * y"));
assertEquals(4F, exec("def x = (Float)2 def y = (float)2 return x * y"));
assertEquals(4D, exec("def x = (Double)2 def y = (double)2 return x * y"));
}
public void testDiv() {
assertEquals(1, exec("def x = (byte)2 def y = (byte)2 return x / y"));
assertEquals(1, exec("def x = (short)2 def y = (byte)2 return x / y"));
assertEquals(1, exec("def x = (char)2 def y = (byte)2 return x / y"));
assertEquals(1, exec("def x = (int)2 def y = (byte)2 return x / y"));
assertEquals(1L, exec("def x = (long)2 def y = (byte)2 return x / y"));
assertEquals(1F, exec("def x = (float)2 def y = (byte)2 return x / y"));
assertEquals(1D, exec("def x = (double)2 def y = (byte)2 return x / y"));
assertEquals(1, exec("def x = (byte)2 def y = (short)2 return x / y"));
assertEquals(1, exec("def x = (short)2 def y = (short)2 return x / y"));
assertEquals(1, exec("def x = (char)2 def y = (short)2 return x / y"));
assertEquals(1, exec("def x = (int)2 def y = (short)2 return x / y"));
assertEquals(1L, exec("def x = (long)2 def y = (short)2 return x / y"));
assertEquals(1F, exec("def x = (float)2 def y = (short)2 return x / y"));
assertEquals(1D, exec("def x = (double)2 def y = (short)2 return x / y"));
assertEquals(1, exec("def x = (byte)2 def y = (char)2 return x / y"));
assertEquals(1, exec("def x = (short)2 def y = (char)2 return x / y"));
assertEquals(1, exec("def x = (char)2 def y = (char)2 return x / y"));
assertEquals(1, exec("def x = (int)2 def y = (char)2 return x / y"));
assertEquals(1L, exec("def x = (long)2 def y = (char)2 return x / y"));
assertEquals(1F, exec("def x = (float)2 def y = (char)2 return x / y"));
assertEquals(1D, exec("def x = (double)2 def y = (char)2 return x / y"));
assertEquals(1, exec("def x = (byte)2 def y = (int)2 return x / y"));
assertEquals(1, exec("def x = (short)2 def y = (int)2 return x / y"));
assertEquals(1, exec("def x = (char)2 def y = (int)2 return x / y"));
assertEquals(1, exec("def x = (int)2 def y = (int)2 return x / y"));
assertEquals(1L, exec("def x = (long)2 def y = (int)2 return x / y"));
assertEquals(1F, exec("def x = (float)2 def y = (int)2 return x / y"));
assertEquals(1D, exec("def x = (double)2 def y = (int)2 return x / y"));
assertEquals(1L, exec("def x = (byte)2 def y = (long)2 return x / y"));
assertEquals(1L, exec("def x = (short)2 def y = (long)2 return x / y"));
assertEquals(1L, exec("def x = (char)2 def y = (long)2 return x / y"));
assertEquals(1L, exec("def x = (int)2 def y = (long)2 return x / y"));
assertEquals(1L, exec("def x = (long)2 def y = (long)2 return x / y"));
assertEquals(1F, exec("def x = (float)2 def y = (long)2 return x / y"));
assertEquals(1D, exec("def x = (double)2 def y = (long)2 return x / y"));
assertEquals(1F, exec("def x = (byte)2 def y = (float)2 return x / y"));
assertEquals(1F, exec("def x = (short)2 def y = (float)2 return x / y"));
assertEquals(1F, exec("def x = (char)2 def y = (float)2 return x / y"));
assertEquals(1F, exec("def x = (int)2 def y = (float)2 return x / y"));
assertEquals(1F, exec("def x = (long)2 def y = (float)2 return x / y"));
assertEquals(1F, exec("def x = (float)2 def y = (float)2 return x / y"));
assertEquals(1D, exec("def x = (double)2 def y = (float)2 return x / y"));
assertEquals(1D, exec("def x = (byte)2 def y = (double)2 return x / y"));
assertEquals(1D, exec("def x = (short)2 def y = (double)2 return x / y"));
assertEquals(1D, exec("def x = (char)2 def y = (double)2 return x / y"));
assertEquals(1D, exec("def x = (int)2 def y = (double)2 return x / y"));
assertEquals(1D, exec("def x = (long)2 def y = (double)2 return x / y"));
assertEquals(1D, exec("def x = (float)2 def y = (double)2 return x / y"));
assertEquals(1D, exec("def x = (double)2 def y = (double)2 return x / y"));
assertEquals(1, exec("def x = (Byte)2 def y = (byte)2 return x / y"));
assertEquals(1, exec("def x = (Short)2 def y = (short)2 return x / y"));
assertEquals(1, exec("def x = (Character)2 def y = (char)2 return x / y"));
assertEquals(1, exec("def x = (Integer)2 def y = (int)2 return x / y"));
assertEquals(1L, exec("def x = (Long)2 def y = (long)2 return x / y"));
assertEquals(1F, exec("def x = (Float)2 def y = (float)2 return x / y"));
assertEquals(1D, exec("def x = (Double)2 def y = (double)2 return x / y"));
}
public void testRem() {
assertEquals(0, exec("def x = (byte)2 def y = (byte)2 return x % y"));
assertEquals(0, exec("def x = (short)2 def y = (byte)2 return x % y"));
assertEquals(0, exec("def x = (char)2 def y = (byte)2 return x % y"));
assertEquals(0, exec("def x = (int)2 def y = (byte)2 return x % y"));
assertEquals(0L, exec("def x = (long)2 def y = (byte)2 return x % y"));
assertEquals(0F, exec("def x = (float)2 def y = (byte)2 return x % y"));
assertEquals(0D, exec("def x = (double)2 def y = (byte)2 return x % y"));
assertEquals(0, exec("def x = (byte)2 def y = (short)2 return x % y"));
assertEquals(0, exec("def x = (short)2 def y = (short)2 return x % y"));
assertEquals(0, exec("def x = (char)2 def y = (short)2 return x % y"));
assertEquals(0, exec("def x = (int)2 def y = (short)2 return x % y"));
assertEquals(0L, exec("def x = (long)2 def y = (short)2 return x % y"));
assertEquals(0F, exec("def x = (float)2 def y = (short)2 return x % y"));
assertEquals(0D, exec("def x = (double)2 def y = (short)2 return x % y"));
assertEquals(0, exec("def x = (byte)2 def y = (char)2 return x % y"));
assertEquals(0, exec("def x = (short)2 def y = (char)2 return x % y"));
assertEquals(0, exec("def x = (char)2 def y = (char)2 return x % y"));
assertEquals(0, exec("def x = (int)2 def y = (char)2 return x % y"));
assertEquals(0L, exec("def x = (long)2 def y = (char)2 return x % y"));
assertEquals(0F, exec("def x = (float)2 def y = (char)2 return x % y"));
assertEquals(0D, exec("def x = (double)2 def y = (char)2 return x % y"));
assertEquals(0, exec("def x = (byte)2 def y = (int)2 return x % y"));
assertEquals(0, exec("def x = (short)2 def y = (int)2 return x % y"));
assertEquals(0, exec("def x = (char)2 def y = (int)2 return x % y"));
assertEquals(0, exec("def x = (int)2 def y = (int)2 return x % y"));
assertEquals(0L, exec("def x = (long)2 def y = (int)2 return x % y"));
assertEquals(0F, exec("def x = (float)2 def y = (int)2 return x % y"));
assertEquals(0D, exec("def x = (double)2 def y = (int)2 return x % y"));
assertEquals(0L, exec("def x = (byte)2 def y = (long)2 return x % y"));
assertEquals(0L, exec("def x = (short)2 def y = (long)2 return x % y"));
assertEquals(0L, exec("def x = (char)2 def y = (long)2 return x % y"));
assertEquals(0L, exec("def x = (int)2 def y = (long)2 return x % y"));
assertEquals(0L, exec("def x = (long)2 def y = (long)2 return x % y"));
assertEquals(0F, exec("def x = (float)2 def y = (long)2 return x % y"));
assertEquals(0D, exec("def x = (double)2 def y = (long)2 return x % y"));
assertEquals(0F, exec("def x = (byte)2 def y = (float)2 return x % y"));
assertEquals(0F, exec("def x = (short)2 def y = (float)2 return x % y"));
assertEquals(0F, exec("def x = (char)2 def y = (float)2 return x % y"));
assertEquals(0F, exec("def x = (int)2 def y = (float)2 return x % y"));
assertEquals(0F, exec("def x = (long)2 def y = (float)2 return x % y"));
assertEquals(0F, exec("def x = (float)2 def y = (float)2 return x % y"));
assertEquals(0D, exec("def x = (double)2 def y = (float)2 return x % y"));
assertEquals(0D, exec("def x = (byte)2 def y = (double)2 return x % y"));
assertEquals(0D, exec("def x = (short)2 def y = (double)2 return x % y"));
assertEquals(0D, exec("def x = (char)2 def y = (double)2 return x % y"));
assertEquals(0D, exec("def x = (int)2 def y = (double)2 return x % y"));
assertEquals(0D, exec("def x = (long)2 def y = (double)2 return x % y"));
assertEquals(0D, exec("def x = (float)2 def y = (double)2 return x % y"));
assertEquals(0D, exec("def x = (double)2 def y = (double)2 return x % y"));
assertEquals(0, exec("def x = (Byte)2 def y = (byte)2 return x % y"));
assertEquals(0, exec("def x = (Short)2 def y = (short)2 return x % y"));
assertEquals(0, exec("def x = (Character)2 def y = (char)2 return x % y"));
assertEquals(0, exec("def x = (Integer)2 def y = (int)2 return x % y"));
assertEquals(0L, exec("def x = (Long)2 def y = (long)2 return x % y"));
assertEquals(0F, exec("def x = (Float)2 def y = (float)2 return x % y"));
assertEquals(0D, exec("def x = (Double)2 def y = (double)2 return x % y"));
}
public void testAdd() {
assertEquals(2, exec("def x = (byte)1 def y = (byte)1 return x + y"));
assertEquals(2, exec("def x = (short)1 def y = (byte)1 return x + y"));
assertEquals(2, exec("def x = (char)1 def y = (byte)1 return x + y"));
assertEquals(2, exec("def x = (int)1 def y = (byte)1 return x + y"));
assertEquals(2L, exec("def x = (long)1 def y = (byte)1 return x + y"));
assertEquals(2F, exec("def x = (float)1 def y = (byte)1 return x + y"));
assertEquals(2D, exec("def x = (double)1 def y = (byte)1 return x + y"));
assertEquals(2, exec("def x = (byte)1 def y = (short)1 return x + y"));
assertEquals(2, exec("def x = (short)1 def y = (short)1 return x + y"));
assertEquals(2, exec("def x = (char)1 def y = (short)1 return x + y"));
assertEquals(2, exec("def x = (int)1 def y = (short)1 return x + y"));
assertEquals(2L, exec("def x = (long)1 def y = (short)1 return x + y"));
assertEquals(2F, exec("def x = (float)1 def y = (short)1 return x + y"));
assertEquals(2D, exec("def x = (double)1 def y = (short)1 return x + y"));
assertEquals(2, exec("def x = (byte)1 def y = (char)1 return x + y"));
assertEquals(2, exec("def x = (short)1 def y = (char)1 return x + y"));
assertEquals(2, exec("def x = (char)1 def y = (char)1 return x + y"));
assertEquals(2, exec("def x = (int)1 def y = (char)1 return x + y"));
assertEquals(2L, exec("def x = (long)1 def y = (char)1 return x + y"));
assertEquals(2F, exec("def x = (float)1 def y = (char)1 return x + y"));
assertEquals(2D, exec("def x = (double)1 def y = (char)1 return x + y"));
assertEquals(2, exec("def x = (byte)1 def y = (int)1 return x + y"));
assertEquals(2, exec("def x = (short)1 def y = (int)1 return x + y"));
assertEquals(2, exec("def x = (char)1 def y = (int)1 return x + y"));
assertEquals(2, exec("def x = (int)1 def y = (int)1 return x + y"));
assertEquals(2L, exec("def x = (long)1 def y = (int)1 return x + y"));
assertEquals(2F, exec("def x = (float)1 def y = (int)1 return x + y"));
assertEquals(2D, exec("def x = (double)1 def y = (int)1 return x + y"));
assertEquals(2L, exec("def x = (byte)1 def y = (long)1 return x + y"));
assertEquals(2L, exec("def x = (short)1 def y = (long)1 return x + y"));
assertEquals(2L, exec("def x = (char)1 def y = (long)1 return x + y"));
assertEquals(2L, exec("def x = (int)1 def y = (long)1 return x + y"));
assertEquals(2L, exec("def x = (long)1 def y = (long)1 return x + y"));
assertEquals(2F, exec("def x = (float)1 def y = (long)1 return x + y"));
assertEquals(2D, exec("def x = (double)1 def y = (long)1 return x + y"));
assertEquals(2F, exec("def x = (byte)1 def y = (float)1 return x + y"));
assertEquals(2F, exec("def x = (short)1 def y = (float)1 return x + y"));
assertEquals(2F, exec("def x = (char)1 def y = (float)1 return x + y"));
assertEquals(2F, exec("def x = (int)1 def y = (float)1 return x + y"));
assertEquals(2F, exec("def x = (long)1 def y = (float)1 return x + y"));
assertEquals(2F, exec("def x = (float)1 def y = (float)1 return x + y"));
assertEquals(2D, exec("def x = (double)1 def y = (float)1 return x + y"));
assertEquals(2D, exec("def x = (byte)1 def y = (double)1 return x + y"));
assertEquals(2D, exec("def x = (short)1 def y = (double)1 return x + y"));
assertEquals(2D, exec("def x = (char)1 def y = (double)1 return x + y"));
assertEquals(2D, exec("def x = (int)1 def y = (double)1 return x + y"));
assertEquals(2D, exec("def x = (long)1 def y = (double)1 return x + y"));
assertEquals(2D, exec("def x = (float)1 def y = (double)1 return x + y"));
assertEquals(2D, exec("def x = (double)1 def y = (double)1 return x + y"));
assertEquals(2, exec("def x = (Byte)1 def y = (byte)1 return x + y"));
assertEquals(2, exec("def x = (Short)1 def y = (short)1 return x + y"));
assertEquals(2, exec("def x = (Character)1 def y = (char)1 return x + y"));
assertEquals(2, exec("def x = (Integer)1 def y = (int)1 return x + y"));
assertEquals(2L, exec("def x = (Long)1 def y = (long)1 return x + y"));
assertEquals(2F, exec("def x = (Float)1 def y = (float)1 return x + y"));
assertEquals(2D, exec("def x = (Double)1 def y = (double)1 return x + y"));
}
public void testSub() {
assertEquals(0, exec("def x = (byte)1 def y = (byte)1 return x - y"));
assertEquals(0, exec("def x = (short)1 def y = (byte)1 return x - y"));
assertEquals(0, exec("def x = (char)1 def y = (byte)1 return x - y"));
assertEquals(0, exec("def x = (int)1 def y = (byte)1 return x - y"));
assertEquals(0L, exec("def x = (long)1 def y = (byte)1 return x - y"));
assertEquals(0F, exec("def x = (float)1 def y = (byte)1 return x - y"));
assertEquals(0D, exec("def x = (double)1 def y = (byte)1 return x - y"));
assertEquals(0, exec("def x = (byte)1 def y = (short)1 return x - y"));
assertEquals(0, exec("def x = (short)1 def y = (short)1 return x - y"));
assertEquals(0, exec("def x = (char)1 def y = (short)1 return x - y"));
assertEquals(0, exec("def x = (int)1 def y = (short)1 return x - y"));
assertEquals(0L, exec("def x = (long)1 def y = (short)1 return x - y"));
assertEquals(0F, exec("def x = (float)1 def y = (short)1 return x - y"));
assertEquals(0D, exec("def x = (double)1 def y = (short)1 return x - y"));
assertEquals(0, exec("def x = (byte)1 def y = (char)1 return x - y"));
assertEquals(0, exec("def x = (short)1 def y = (char)1 return x - y"));
assertEquals(0, exec("def x = (char)1 def y = (char)1 return x - y"));
assertEquals(0, exec("def x = (int)1 def y = (char)1 return x - y"));
assertEquals(0L, exec("def x = (long)1 def y = (char)1 return x - y"));
assertEquals(0F, exec("def x = (float)1 def y = (char)1 return x - y"));
assertEquals(0D, exec("def x = (double)1 def y = (char)1 return x - y"));
assertEquals(0, exec("def x = (byte)1 def y = (int)1 return x - y"));
assertEquals(0, exec("def x = (short)1 def y = (int)1 return x - y"));
assertEquals(0, exec("def x = (char)1 def y = (int)1 return x - y"));
assertEquals(0, exec("def x = (int)1 def y = (int)1 return x - y"));
assertEquals(0L, exec("def x = (long)1 def y = (int)1 return x - y"));
assertEquals(0F, exec("def x = (float)1 def y = (int)1 return x - y"));
assertEquals(0D, exec("def x = (double)1 def y = (int)1 return x - y"));
assertEquals(0L, exec("def x = (byte)1 def y = (long)1 return x - y"));
assertEquals(0L, exec("def x = (short)1 def y = (long)1 return x - y"));
assertEquals(0L, exec("def x = (char)1 def y = (long)1 return x - y"));
assertEquals(0L, exec("def x = (int)1 def y = (long)1 return x - y"));
assertEquals(0L, exec("def x = (long)1 def y = (long)1 return x - y"));
assertEquals(0F, exec("def x = (float)1 def y = (long)1 return x - y"));
assertEquals(0D, exec("def x = (double)1 def y = (long)1 return x - y"));
assertEquals(0F, exec("def x = (byte)1 def y = (float)1 return x - y"));
assertEquals(0F, exec("def x = (short)1 def y = (float)1 return x - y"));
assertEquals(0F, exec("def x = (char)1 def y = (float)1 return x - y"));
assertEquals(0F, exec("def x = (int)1 def y = (float)1 return x - y"));
assertEquals(0F, exec("def x = (long)1 def y = (float)1 return x - y"));
assertEquals(0F, exec("def x = (float)1 def y = (float)1 return x - y"));
assertEquals(0D, exec("def x = (double)1 def y = (float)1 return x - y"));
assertEquals(0D, exec("def x = (byte)1 def y = (double)1 return x - y"));
assertEquals(0D, exec("def x = (short)1 def y = (double)1 return x - y"));
assertEquals(0D, exec("def x = (char)1 def y = (double)1 return x - y"));
assertEquals(0D, exec("def x = (int)1 def y = (double)1 return x - y"));
assertEquals(0D, exec("def x = (long)1 def y = (double)1 return x - y"));
assertEquals(0D, exec("def x = (float)1 def y = (double)1 return x - y"));
assertEquals(0D, exec("def x = (double)1 def y = (double)1 return x - y"));
assertEquals(0, exec("def x = (Byte)1 def y = (byte)1 return x - y"));
assertEquals(0, exec("def x = (Short)1 def y = (short)1 return x - y"));
assertEquals(0, exec("def x = (Character)1 def y = (char)1 return x - y"));
assertEquals(0, exec("def x = (Integer)1 def y = (int)1 return x - y"));
assertEquals(0L, exec("def x = (Long)1 def y = (long)1 return x - y"));
assertEquals(0F, exec("def x = (Float)1 def y = (float)1 return x - y"));
assertEquals(0D, exec("def x = (Double)1 def y = (double)1 return x - y"));
}
public void testLsh() {
assertEquals(2, exec("def x = (byte)1 def y = (byte)1 return x << y"));
assertEquals(2, exec("def x = (short)1 def y = (byte)1 return x << y"));
assertEquals(2, exec("def x = (char)1 def y = (byte)1 return x << y"));
assertEquals(2, exec("def x = (int)1 def y = (byte)1 return x << y"));
assertEquals(2L, exec("def x = (long)1 def y = (byte)1 return x << y"));
assertEquals(2L, exec("def x = (float)1 def y = (byte)1 return x << y"));
assertEquals(2L, exec("def x = (double)1 def y = (byte)1 return x << y"));
assertEquals(2, exec("def x = (byte)1 def y = (short)1 return x << y"));
assertEquals(2, exec("def x = (short)1 def y = (short)1 return x << y"));
assertEquals(2, exec("def x = (char)1 def y = (short)1 return x << y"));
assertEquals(2, exec("def x = (int)1 def y = (short)1 return x << y"));
assertEquals(2L, exec("def x = (long)1 def y = (short)1 return x << y"));
assertEquals(2L, exec("def x = (float)1 def y = (short)1 return x << y"));
assertEquals(2L, exec("def x = (double)1 def y = (short)1 return x << y"));
assertEquals(2, exec("def x = (byte)1 def y = (char)1 return x << y"));
assertEquals(2, exec("def x = (short)1 def y = (char)1 return x << y"));
assertEquals(2, exec("def x = (char)1 def y = (char)1 return x << y"));
assertEquals(2, exec("def x = (int)1 def y = (char)1 return x << y"));
assertEquals(2L, exec("def x = (long)1 def y = (char)1 return x << y"));
assertEquals(2L, exec("def x = (float)1 def y = (char)1 return x << y"));
assertEquals(2L, exec("def x = (double)1 def y = (char)1 return x << y"));
assertEquals(2, exec("def x = (byte)1 def y = (int)1 return x << y"));
assertEquals(2, exec("def x = (short)1 def y = (int)1 return x << y"));
assertEquals(2, exec("def x = (char)1 def y = (int)1 return x << y"));
assertEquals(2, exec("def x = (int)1 def y = (int)1 return x << y"));
assertEquals(2L, exec("def x = (long)1 def y = (int)1 return x << y"));
assertEquals(2L, exec("def x = (float)1 def y = (int)1 return x << y"));
assertEquals(2L, exec("def x = (double)1 def y = (int)1 return x << y"));
assertEquals(2L, exec("def x = (byte)1 def y = (long)1 return x << y"));
assertEquals(2L, exec("def x = (short)1 def y = (long)1 return x << y"));
assertEquals(2L, exec("def x = (char)1 def y = (long)1 return x << y"));
assertEquals(2L, exec("def x = (int)1 def y = (long)1 return x << y"));
assertEquals(2L, exec("def x = (long)1 def y = (long)1 return x << y"));
assertEquals(2L, exec("def x = (float)1 def y = (long)1 return x << y"));
assertEquals(2L, exec("def x = (double)1 def y = (long)1 return x << y"));
assertEquals(2L, exec("def x = (byte)1 def y = (float)1 return x << y"));
assertEquals(2L, exec("def x = (short)1 def y = (float)1 return x << y"));
assertEquals(2L, exec("def x = (char)1 def y = (float)1 return x << y"));
assertEquals(2L, exec("def x = (int)1 def y = (float)1 return x << y"));
assertEquals(2L, exec("def x = (long)1 def y = (float)1 return x << y"));
assertEquals(2L, exec("def x = (float)1 def y = (float)1 return x << y"));
assertEquals(2L, exec("def x = (double)1 def y = (float)1 return x << y"));
assertEquals(2L, exec("def x = (byte)1 def y = (double)1 return x << y"));
assertEquals(2L, exec("def x = (short)1 def y = (double)1 return x << y"));
assertEquals(2L, exec("def x = (char)1 def y = (double)1 return x << y"));
assertEquals(2L, exec("def x = (int)1 def y = (double)1 return x << y"));
assertEquals(2L, exec("def x = (long)1 def y = (double)1 return x << y"));
assertEquals(2L, exec("def x = (float)1 def y = (double)1 return x << y"));
assertEquals(2L, exec("def x = (double)1 def y = (double)1 return x << y"));
assertEquals(2, exec("def x = (Byte)1 def y = (byte)1 return x << y"));
assertEquals(2, exec("def x = (Short)1 def y = (short)1 return x << y"));
assertEquals(2, exec("def x = (Character)1 def y = (char)1 return x << y"));
assertEquals(2, exec("def x = (Integer)1 def y = (int)1 return x << y"));
assertEquals(2L, exec("def x = (Long)1 def y = (long)1 return x << y"));
assertEquals(2L, exec("def x = (Float)1 def y = (float)1 return x << y"));
assertEquals(2L, exec("def x = (Double)1 def y = (double)1 return x << y"));
}
public void testRsh() {
assertEquals(2, exec("def x = (byte)4 def y = (byte)1 return x >> y"));
assertEquals(2, exec("def x = (short)4 def y = (byte)1 return x >> y"));
assertEquals(2, exec("def x = (char)4 def y = (byte)1 return x >> y"));
assertEquals(2, exec("def x = (int)4 def y = (byte)1 return x >> y"));
assertEquals(2L, exec("def x = (long)4 def y = (byte)1 return x >> y"));
assertEquals(2L, exec("def x = (float)4 def y = (byte)1 return x >> y"));
assertEquals(2L, exec("def x = (double)4 def y = (byte)1 return x >> y"));
assertEquals(2, exec("def x = (byte)4 def y = (short)1 return x >> y"));
assertEquals(2, exec("def x = (short)4 def y = (short)1 return x >> y"));
assertEquals(2, exec("def x = (char)4 def y = (short)1 return x >> y"));
assertEquals(2, exec("def x = (int)4 def y = (short)1 return x >> y"));
assertEquals(2L, exec("def x = (long)4 def y = (short)1 return x >> y"));
assertEquals(2L, exec("def x = (float)4 def y = (short)1 return x >> y"));
assertEquals(2L, exec("def x = (double)4 def y = (short)1 return x >> y"));
assertEquals(2, exec("def x = (byte)4 def y = (char)1 return x >> y"));
assertEquals(2, exec("def x = (short)4 def y = (char)1 return x >> y"));
assertEquals(2, exec("def x = (char)4 def y = (char)1 return x >> y"));
assertEquals(2, exec("def x = (int)4 def y = (char)1 return x >> y"));
assertEquals(2L, exec("def x = (long)4 def y = (char)1 return x >> y"));
assertEquals(2L, exec("def x = (float)4 def y = (char)1 return x >> y"));
assertEquals(2L, exec("def x = (double)4 def y = (char)1 return x >> y"));
assertEquals(2, exec("def x = (byte)4 def y = (int)1 return x >> y"));
assertEquals(2, exec("def x = (short)4 def y = (int)1 return x >> y"));
assertEquals(2, exec("def x = (char)4 def y = (int)1 return x >> y"));
assertEquals(2, exec("def x = (int)4 def y = (int)1 return x >> y"));
assertEquals(2L, exec("def x = (long)4 def y = (int)1 return x >> y"));
assertEquals(2L, exec("def x = (float)4 def y = (int)1 return x >> y"));
assertEquals(2L, exec("def x = (double)4 def y = (int)1 return x >> y"));
assertEquals(2L, exec("def x = (byte)4 def y = (long)1 return x >> y"));
assertEquals(2L, exec("def x = (short)4 def y = (long)1 return x >> y"));
assertEquals(2L, exec("def x = (char)4 def y = (long)1 return x >> y"));
assertEquals(2L, exec("def x = (int)4 def y = (long)1 return x >> y"));
assertEquals(2L, exec("def x = (long)4 def y = (long)1 return x >> y"));
assertEquals(2L, exec("def x = (float)4 def y = (long)1 return x >> y"));
assertEquals(2L, exec("def x = (double)4 def y = (long)1 return x >> y"));
assertEquals(2L, exec("def x = (byte)4 def y = (float)1 return x >> y"));
assertEquals(2L, exec("def x = (short)4 def y = (float)1 return x >> y"));
assertEquals(2L, exec("def x = (char)4 def y = (float)1 return x >> y"));
assertEquals(2L, exec("def x = (int)4 def y = (float)1 return x >> y"));
assertEquals(2L, exec("def x = (long)4 def y = (float)1 return x >> y"));
assertEquals(2L, exec("def x = (float)4 def y = (float)1 return x >> y"));
assertEquals(2L, exec("def x = (double)4 def y = (float)1 return x >> y"));
assertEquals(2L, exec("def x = (byte)4 def y = (double)1 return x >> y"));
assertEquals(2L, exec("def x = (short)4 def y = (double)1 return x >> y"));
assertEquals(2L, exec("def x = (char)4 def y = (double)1 return x >> y"));
assertEquals(2L, exec("def x = (int)4 def y = (double)1 return x >> y"));
assertEquals(2L, exec("def x = (long)4 def y = (double)1 return x >> y"));
assertEquals(2L, exec("def x = (float)4 def y = (double)1 return x >> y"));
assertEquals(2L, exec("def x = (double)4 def y = (double)1 return x >> y"));
assertEquals(2, exec("def x = (Byte)4 def y = (byte)1 return x >> y"));
assertEquals(2, exec("def x = (Short)4 def y = (short)1 return x >> y"));
assertEquals(2, exec("def x = (Character)4 def y = (char)1 return x >> y"));
assertEquals(2, exec("def x = (Integer)4 def y = (int)1 return x >> y"));
assertEquals(2L, exec("def x = (Long)4 def y = (long)1 return x >> y"));
assertEquals(2L, exec("def x = (Float)4 def y = (float)1 return x >> y"));
assertEquals(2L, exec("def x = (Double)4 def y = (double)1 return x >> y"));
}
public void testUsh() {
assertEquals(2, exec("def x = (byte)4 def y = (byte)1 return x >>> y"));
assertEquals(2, exec("def x = (short)4 def y = (byte)1 return x >>> y"));
assertEquals(2, exec("def x = (char)4 def y = (byte)1 return x >>> y"));
assertEquals(2, exec("def x = (int)4 def y = (byte)1 return x >>> y"));
assertEquals(2L, exec("def x = (long)4 def y = (byte)1 return x >>> y"));
assertEquals(2L, exec("def x = (float)4 def y = (byte)1 return x >>> y"));
assertEquals(2L, exec("def x = (double)4 def y = (byte)1 return x >>> y"));
assertEquals(2, exec("def x = (byte)4 def y = (short)1 return x >>> y"));
assertEquals(2, exec("def x = (short)4 def y = (short)1 return x >>> y"));
assertEquals(2, exec("def x = (char)4 def y = (short)1 return x >>> y"));
assertEquals(2, exec("def x = (int)4 def y = (short)1 return x >>> y"));
assertEquals(2L, exec("def x = (long)4 def y = (short)1 return x >>> y"));
assertEquals(2L, exec("def x = (float)4 def y = (short)1 return x >>> y"));
assertEquals(2L, exec("def x = (double)4 def y = (short)1 return x >>> y"));
assertEquals(2, exec("def x = (byte)4 def y = (char)1 return x >>> y"));
assertEquals(2, exec("def x = (short)4 def y = (char)1 return x >>> y"));
assertEquals(2, exec("def x = (char)4 def y = (char)1 return x >>> y"));
assertEquals(2, exec("def x = (int)4 def y = (char)1 return x >>> y"));
assertEquals(2L, exec("def x = (long)4 def y = (char)1 return x >>> y"));
assertEquals(2L, exec("def x = (float)4 def y = (char)1 return x >>> y"));
assertEquals(2L, exec("def x = (double)4 def y = (char)1 return x >>> y"));
assertEquals(2, exec("def x = (byte)4 def y = (int)1 return x >>> y"));
assertEquals(2, exec("def x = (short)4 def y = (int)1 return x >>> y"));
assertEquals(2, exec("def x = (char)4 def y = (int)1 return x >>> y"));
assertEquals(2, exec("def x = (int)4 def y = (int)1 return x >>> y"));
assertEquals(2L, exec("def x = (long)4 def y = (int)1 return x >>> y"));
assertEquals(2L, exec("def x = (float)4 def y = (int)1 return x >>> y"));
assertEquals(2L, exec("def x = (double)4 def y = (int)1 return x >>> y"));
assertEquals(2L, exec("def x = (byte)4 def y = (long)1 return x >>> y"));
assertEquals(2L, exec("def x = (short)4 def y = (long)1 return x >>> y"));
assertEquals(2L, exec("def x = (char)4 def y = (long)1 return x >>> y"));
assertEquals(2L, exec("def x = (int)4 def y = (long)1 return x >>> y"));
assertEquals(2L, exec("def x = (long)4 def y = (long)1 return x >>> y"));
assertEquals(2L, exec("def x = (float)4 def y = (long)1 return x >>> y"));
assertEquals(2L, exec("def x = (double)4 def y = (long)1 return x >>> y"));
assertEquals(2L, exec("def x = (byte)4 def y = (float)1 return x >>> y"));
assertEquals(2L, exec("def x = (short)4 def y = (float)1 return x >>> y"));
assertEquals(2L, exec("def x = (char)4 def y = (float)1 return x >>> y"));
assertEquals(2L, exec("def x = (int)4 def y = (float)1 return x >>> y"));
assertEquals(2L, exec("def x = (long)4 def y = (float)1 return x >>> y"));
assertEquals(2L, exec("def x = (float)4 def y = (float)1 return x >>> y"));
assertEquals(2L, exec("def x = (double)4 def y = (float)1 return x >>> y"));
assertEquals(2L, exec("def x = (byte)4 def y = (double)1 return x >>> y"));
assertEquals(2L, exec("def x = (short)4 def y = (double)1 return x >>> y"));
assertEquals(2L, exec("def x = (char)4 def y = (double)1 return x >>> y"));
assertEquals(2L, exec("def x = (int)4 def y = (double)1 return x >>> y"));
assertEquals(2L, exec("def x = (long)4 def y = (double)1 return x >>> y"));
assertEquals(2L, exec("def x = (float)4 def y = (double)1 return x >>> y"));
assertEquals(2L, exec("def x = (double)4 def y = (double)1 return x >>> y"));
assertEquals(2, exec("def x = (Byte)4 def y = (byte)1 return x >>> y"));
assertEquals(2, exec("def x = (Short)4 def y = (short)1 return x >>> y"));
assertEquals(2, exec("def x = (Character)4 def y = (char)1 return x >>> y"));
assertEquals(2, exec("def x = (Integer)4 def y = (int)1 return x >>> y"));
assertEquals(2L, exec("def x = (Long)4 def y = (long)1 return x >>> y"));
assertEquals(2L, exec("def x = (Float)4 def y = (float)1 return x >>> y"));
assertEquals(2L, exec("def x = (Double)4 def y = (double)1 return x >>> y"));
}
public void testAnd() {
assertEquals(0, exec("def x = (byte)4 def y = (byte)1 return x & y"));
assertEquals(0, exec("def x = (short)4 def y = (byte)1 return x & y"));
assertEquals(0, exec("def x = (char)4 def y = (byte)1 return x & y"));
assertEquals(0, exec("def x = (int)4 def y = (byte)1 return x & y"));
assertEquals(0L, exec("def x = (long)4 def y = (byte)1 return x & y"));
assertEquals(0L, exec("def x = (float)4 def y = (byte)1 return x & y"));
assertEquals(0L, exec("def x = (double)4 def y = (byte)1 return x & y"));
assertEquals(0, exec("def x = (byte)4 def y = (short)1 return x & y"));
assertEquals(0, exec("def x = (short)4 def y = (short)1 return x & y"));
assertEquals(0, exec("def x = (char)4 def y = (short)1 return x & y"));
assertEquals(0, exec("def x = (int)4 def y = (short)1 return x & y"));
assertEquals(0L, exec("def x = (long)4 def y = (short)1 return x & y"));
assertEquals(0L, exec("def x = (float)4 def y = (short)1 return x & y"));
assertEquals(0L, exec("def x = (double)4 def y = (short)1 return x & y"));
assertEquals(0, exec("def x = (byte)4 def y = (char)1 return x & y"));
assertEquals(0, exec("def x = (short)4 def y = (char)1 return x & y"));
assertEquals(0, exec("def x = (char)4 def y = (char)1 return x & y"));
assertEquals(0, exec("def x = (int)4 def y = (char)1 return x & y"));
assertEquals(0L, exec("def x = (long)4 def y = (char)1 return x & y"));
assertEquals(0L, exec("def x = (float)4 def y = (char)1 return x & y"));
assertEquals(0L, exec("def x = (double)4 def y = (char)1 return x & y"));
assertEquals(0, exec("def x = (byte)4 def y = (int)1 return x & y"));
assertEquals(0, exec("def x = (short)4 def y = (int)1 return x & y"));
assertEquals(0, exec("def x = (char)4 def y = (int)1 return x & y"));
assertEquals(0, exec("def x = (int)4 def y = (int)1 return x & y"));
assertEquals(0L, exec("def x = (long)4 def y = (int)1 return x & y"));
assertEquals(0L, exec("def x = (float)4 def y = (int)1 return x & y"));
assertEquals(0L, exec("def x = (double)4 def y = (int)1 return x & y"));
assertEquals(0L, exec("def x = (byte)4 def y = (long)1 return x & y"));
assertEquals(0L, exec("def x = (short)4 def y = (long)1 return x & y"));
assertEquals(0L, exec("def x = (char)4 def y = (long)1 return x & y"));
assertEquals(0L, exec("def x = (int)4 def y = (long)1 return x & y"));
assertEquals(0L, exec("def x = (long)4 def y = (long)1 return x & y"));
assertEquals(0L, exec("def x = (float)4 def y = (long)1 return x & y"));
assertEquals(0L, exec("def x = (double)4 def y = (long)1 return x & y"));
assertEquals(0L, exec("def x = (byte)4 def y = (float)1 return x & y"));
assertEquals(0L, exec("def x = (short)4 def y = (float)1 return x & y"));
assertEquals(0L, exec("def x = (char)4 def y = (float)1 return x & y"));
assertEquals(0L, exec("def x = (int)4 def y = (float)1 return x & y"));
assertEquals(0L, exec("def x = (long)4 def y = (float)1 return x & y"));
assertEquals(0L, exec("def x = (float)4 def y = (float)1 return x & y"));
assertEquals(0L, exec("def x = (double)4 def y = (float)1 return x & y"));
assertEquals(0L, exec("def x = (byte)4 def y = (double)1 return x & y"));
assertEquals(0L, exec("def x = (short)4 def y = (double)1 return x & y"));
assertEquals(0L, exec("def x = (char)4 def y = (double)1 return x & y"));
assertEquals(0L, exec("def x = (int)4 def y = (double)1 return x & y"));
assertEquals(0L, exec("def x = (long)4 def y = (double)1 return x & y"));
assertEquals(0L, exec("def x = (float)4 def y = (double)1 return x & y"));
assertEquals(0L, exec("def x = (double)4 def y = (double)1 return x & y"));
assertEquals(0, exec("def x = (Byte)4 def y = (byte)1 return x & y"));
assertEquals(0, exec("def x = (Short)4 def y = (short)1 return x & y"));
assertEquals(0, exec("def x = (Character)4 def y = (char)1 return x & y"));
assertEquals(0, exec("def x = (Integer)4 def y = (int)1 return x & y"));
assertEquals(0L, exec("def x = (Long)4 def y = (long)1 return x & y"));
assertEquals(0L, exec("def x = (Float)4 def y = (float)1 return x & y"));
assertEquals(0L, exec("def x = (Double)4 def y = (double)1 return x & y"));
}
public void testXor() {
assertEquals(5, exec("def x = (byte)4 def y = (byte)1 return x ^ y"));
assertEquals(5, exec("def x = (short)4 def y = (byte)1 return x ^ y"));
assertEquals(5, exec("def x = (char)4 def y = (byte)1 return x ^ y"));
assertEquals(5, exec("def x = (int)4 def y = (byte)1 return x ^ y"));
assertEquals(5L, exec("def x = (long)4 def y = (byte)1 return x ^ y"));
assertEquals(5L, exec("def x = (float)4 def y = (byte)1 return x ^ y"));
assertEquals(5L, exec("def x = (double)4 def y = (byte)1 return x ^ y"));
assertEquals(5, exec("def x = (byte)4 def y = (short)1 return x ^ y"));
assertEquals(5, exec("def x = (short)4 def y = (short)1 return x ^ y"));
assertEquals(5, exec("def x = (char)4 def y = (short)1 return x ^ y"));
assertEquals(5, exec("def x = (int)4 def y = (short)1 return x ^ y"));
assertEquals(5L, exec("def x = (long)4 def y = (short)1 return x ^ y"));
assertEquals(5L, exec("def x = (float)4 def y = (short)1 return x ^ y"));
assertEquals(5L, exec("def x = (double)4 def y = (short)1 return x ^ y"));
assertEquals(5, exec("def x = (byte)4 def y = (char)1 return x ^ y"));
assertEquals(5, exec("def x = (short)4 def y = (char)1 return x ^ y"));
assertEquals(5, exec("def x = (char)4 def y = (char)1 return x ^ y"));
assertEquals(5, exec("def x = (int)4 def y = (char)1 return x ^ y"));
assertEquals(5L, exec("def x = (long)4 def y = (char)1 return x ^ y"));
assertEquals(5L, exec("def x = (float)4 def y = (char)1 return x ^ y"));
assertEquals(5L, exec("def x = (double)4 def y = (char)1 return x ^ y"));
assertEquals(5, exec("def x = (byte)4 def y = (int)1 return x ^ y"));
assertEquals(5, exec("def x = (short)4 def y = (int)1 return x ^ y"));
assertEquals(5, exec("def x = (char)4 def y = (int)1 return x ^ y"));
assertEquals(5, exec("def x = (int)4 def y = (int)1 return x ^ y"));
assertEquals(5L, exec("def x = (long)4 def y = (int)1 return x ^ y"));
assertEquals(5L, exec("def x = (float)4 def y = (int)1 return x ^ y"));
assertEquals(5L, exec("def x = (double)4 def y = (int)1 return x ^ y"));
assertEquals(5L, exec("def x = (byte)4 def y = (long)1 return x ^ y"));
assertEquals(5L, exec("def x = (short)4 def y = (long)1 return x ^ y"));
assertEquals(5L, exec("def x = (char)4 def y = (long)1 return x ^ y"));
assertEquals(5L, exec("def x = (int)4 def y = (long)1 return x ^ y"));
assertEquals(5L, exec("def x = (long)4 def y = (long)1 return x ^ y"));
assertEquals(5L, exec("def x = (float)4 def y = (long)1 return x ^ y"));
assertEquals(5L, exec("def x = (double)4 def y = (long)1 return x ^ y"));
assertEquals(5L, exec("def x = (byte)4 def y = (float)1 return x ^ y"));
assertEquals(5L, exec("def x = (short)4 def y = (float)1 return x ^ y"));
assertEquals(5L, exec("def x = (char)4 def y = (float)1 return x ^ y"));
assertEquals(5L, exec("def x = (int)4 def y = (float)1 return x ^ y"));
assertEquals(5L, exec("def x = (long)4 def y = (float)1 return x ^ y"));
assertEquals(5L, exec("def x = (float)4 def y = (float)1 return x ^ y"));
assertEquals(5L, exec("def x = (double)4 def y = (float)1 return x ^ y"));
assertEquals(5L, exec("def x = (byte)4 def y = (double)1 return x ^ y"));
assertEquals(5L, exec("def x = (short)4 def y = (double)1 return x ^ y"));
assertEquals(5L, exec("def x = (char)4 def y = (double)1 return x ^ y"));
assertEquals(5L, exec("def x = (int)4 def y = (double)1 return x ^ y"));
assertEquals(5L, exec("def x = (long)4 def y = (double)1 return x ^ y"));
assertEquals(5L, exec("def x = (float)4 def y = (double)1 return x ^ y"));
assertEquals(5L, exec("def x = (double)4 def y = (double)1 return x ^ y"));
assertEquals(5, exec("def x = (Byte)4 def y = (byte)1 return x ^ y"));
assertEquals(5, exec("def x = (Short)4 def y = (short)1 return x ^ y"));
assertEquals(5, exec("def x = (Character)4 def y = (char)1 return x ^ y"));
assertEquals(5, exec("def x = (Integer)4 def y = (int)1 return x ^ y"));
assertEquals(5L, exec("def x = (Long)4 def y = (long)1 return x ^ y"));
assertEquals(5L, exec("def x = (Float)4 def y = (float)1 return x ^ y"));
assertEquals(5L, exec("def x = (Double)4 def y = (double)1 return x ^ y"));
}
public void testOr() {
assertEquals(5, exec("def x = (byte)4 def y = (byte)1 return x | y"));
assertEquals(5, exec("def x = (short)4 def y = (byte)1 return x | y"));
assertEquals(5, exec("def x = (char)4 def y = (byte)1 return x | y"));
assertEquals(5, exec("def x = (int)4 def y = (byte)1 return x | y"));
assertEquals(5L, exec("def x = (long)4 def y = (byte)1 return x | y"));
assertEquals(5L, exec("def x = (float)4 def y = (byte)1 return x | y"));
assertEquals(5L, exec("def x = (double)4 def y = (byte)1 return x | y"));
assertEquals(5, exec("def x = (byte)4 def y = (short)1 return x | y"));
assertEquals(5, exec("def x = (short)4 def y = (short)1 return x | y"));
assertEquals(5, exec("def x = (char)4 def y = (short)1 return x | y"));
assertEquals(5, exec("def x = (int)4 def y = (short)1 return x | y"));
assertEquals(5L, exec("def x = (long)4 def y = (short)1 return x | y"));
assertEquals(5L, exec("def x = (float)4 def y = (short)1 return x | y"));
assertEquals(5L, exec("def x = (double)4 def y = (short)1 return x | y"));
assertEquals(5, exec("def x = (byte)4 def y = (char)1 return x | y"));
assertEquals(5, exec("def x = (short)4 def y = (char)1 return x | y"));
assertEquals(5, exec("def x = (char)4 def y = (char)1 return x | y"));
assertEquals(5, exec("def x = (int)4 def y = (char)1 return x | y"));
assertEquals(5L, exec("def x = (long)4 def y = (char)1 return x | y"));
assertEquals(5L, exec("def x = (float)4 def y = (char)1 return x | y"));
assertEquals(5L, exec("def x = (double)4 def y = (char)1 return x | y"));
assertEquals(5, exec("def x = (byte)4 def y = (int)1 return x | y"));
assertEquals(5, exec("def x = (short)4 def y = (int)1 return x | y"));
assertEquals(5, exec("def x = (char)4 def y = (int)1 return x | y"));
assertEquals(5, exec("def x = (int)4 def y = (int)1 return x | y"));
assertEquals(5L, exec("def x = (long)4 def y = (int)1 return x | y"));
assertEquals(5L, exec("def x = (float)4 def y = (int)1 return x | y"));
assertEquals(5L, exec("def x = (double)4 def y = (int)1 return x | y"));
assertEquals(5L, exec("def x = (byte)4 def y = (long)1 return x | y"));
assertEquals(5L, exec("def x = (short)4 def y = (long)1 return x | y"));
assertEquals(5L, exec("def x = (char)4 def y = (long)1 return x | y"));
assertEquals(5L, exec("def x = (int)4 def y = (long)1 return x | y"));
assertEquals(5L, exec("def x = (long)4 def y = (long)1 return x | y"));
assertEquals(5L, exec("def x = (float)4 def y = (long)1 return x | y"));
assertEquals(5L, exec("def x = (double)4 def y = (long)1 return x | y"));
assertEquals(5L, exec("def x = (byte)4 def y = (float)1 return x | y"));
assertEquals(5L, exec("def x = (short)4 def y = (float)1 return x | y"));
assertEquals(5L, exec("def x = (char)4 def y = (float)1 return x | y"));
assertEquals(5L, exec("def x = (int)4 def y = (float)1 return x | y"));
assertEquals(5L, exec("def x = (long)4 def y = (float)1 return x | y"));
assertEquals(5L, exec("def x = (float)4 def y = (float)1 return x | y"));
assertEquals(5L, exec("def x = (double)4 def y = (float)1 return x | y"));
assertEquals(5L, exec("def x = (byte)4 def y = (double)1 return x | y"));
assertEquals(5L, exec("def x = (short)4 def y = (double)1 return x | y"));
assertEquals(5L, exec("def x = (char)4 def y = (double)1 return x | y"));
assertEquals(5L, exec("def x = (int)4 def y = (double)1 return x | y"));
assertEquals(5L, exec("def x = (long)4 def y = (double)1 return x | y"));
assertEquals(5L, exec("def x = (float)4 def y = (double)1 return x | y"));
assertEquals(5L, exec("def x = (double)4 def y = (double)1 return x | y"));
assertEquals(5, exec("def x = (Byte)4 def y = (byte)1 return x | y"));
assertEquals(5, exec("def x = (Short)4 def y = (short)1 return x | y"));
assertEquals(5, exec("def x = (Character)4 def y = (char)1 return x | y"));
assertEquals(5, exec("def x = (Integer)4 def y = (int)1 return x | y"));
assertEquals(5L, exec("def x = (Long)4 def y = (long)1 return x | y"));
assertEquals(5L, exec("def x = (Float)4 def y = (float)1 return x | y"));
assertEquals(5L, exec("def x = (Double)4 def y = (double)1 return x | y"));
}
public void testEq() {
assertEquals(true, exec("def x = (byte)7 def y = (int)7 return x == y"));
assertEquals(true, exec("def x = (short)6 def y = (int)6 return x == y"));
assertEquals(true, exec("def x = (char)5 def y = (int)5 return x == y"));
assertEquals(true, exec("def x = (int)4 def y = (int)4 return x == y"));
assertEquals(false, exec("def x = (long)5 def y = (int)3 return x == y"));
assertEquals(false, exec("def x = (float)6 def y = (int)2 return x == y"));
assertEquals(false, exec("def x = (double)7 def y = (int)1 return x == y"));
assertEquals(true, exec("def x = (byte)7 def y = (double)7 return x == y"));
assertEquals(true, exec("def x = (short)6 def y = (double)6 return x == y"));
assertEquals(true, exec("def x = (char)5 def y = (double)5 return x == y"));
assertEquals(true, exec("def x = (int)4 def y = (double)4 return x == y"));
assertEquals(false, exec("def x = (long)5 def y = (double)3 return x == y"));
assertEquals(false, exec("def x = (float)6 def y = (double)2 return x == y"));
assertEquals(false, exec("def x = (double)7 def y = (double)1 return x == y"));
assertEquals(true, exec("def x = new HashMap() def y = new HashMap() return x == y"));
assertEquals(false, exec("def x = new HashMap() x.put(3, 3) def y = new HashMap() return x == y"));
assertEquals(true, exec("def x = new HashMap() x.put(3, 3) def y = new HashMap() y.put(3, 3) return x == y"));
assertEquals(true, exec("def x = new HashMap() def y = x x.put(3, 3) y.put(3, 3) return x == y"));
}
public void testEqr() {
assertEquals(false, exec("def x = (byte)7 def y = (int)7 return x === y"));
assertEquals(false, exec("def x = (short)6 def y = (int)6 return x === y"));
assertEquals(false, exec("def x = (char)5 def y = (int)5 return x === y"));
assertEquals(true, exec("def x = (int)4 def y = (int)4 return x === y"));
assertEquals(false, exec("def x = (long)5 def y = (int)3 return x === y"));
assertEquals(false, exec("def x = (float)6 def y = (int)2 return x === y"));
assertEquals(false, exec("def x = (double)7 def y = (int)1 return x === y"));
assertEquals(false, exec("def x = new HashMap() def y = new HashMap() return x === y"));
assertEquals(false, exec("def x = new HashMap() x.put(3, 3) def y = new HashMap() return x === y"));
assertEquals(false, exec("def x = new HashMap() x.put(3, 3) def y = new HashMap() y.put(3, 3) return x === y"));
assertEquals(true, exec("def x = new HashMap() def y = x x.put(3, 3) y.put(3, 3) return x === y"));
}
public void testNe() {
assertEquals(false, exec("def x = (byte)7 def y = (int)7 return x != y"));
assertEquals(false, exec("def x = (short)6 def y = (int)6 return x != y"));
assertEquals(false, exec("def x = (char)5 def y = (int)5 return x != y"));
assertEquals(false, exec("def x = (int)4 def y = (int)4 return x != y"));
assertEquals(true, exec("def x = (long)5 def y = (int)3 return x != y"));
assertEquals(true, exec("def x = (float)6 def y = (int)2 return x != y"));
assertEquals(true, exec("def x = (double)7 def y = (int)1 return x != y"));
assertEquals(false, exec("def x = (byte)7 def y = (double)7 return x != y"));
assertEquals(false, exec("def x = (short)6 def y = (double)6 return x != y"));
assertEquals(false, exec("def x = (char)5 def y = (double)5 return x != y"));
assertEquals(false, exec("def x = (int)4 def y = (double)4 return x != y"));
assertEquals(true, exec("def x = (long)5 def y = (double)3 return x != y"));
assertEquals(true, exec("def x = (float)6 def y = (double)2 return x != y"));
assertEquals(true, exec("def x = (double)7 def y = (double)1 return x != y"));
assertEquals(false, exec("def x = new HashMap() def y = new HashMap() return x != y"));
assertEquals(true, exec("def x = new HashMap() x.put(3, 3) def y = new HashMap() return x != y"));
assertEquals(false, exec("def x = new HashMap() x.put(3, 3) def y = new HashMap() y.put(3, 3) return x != y"));
assertEquals(false, exec("def x = new HashMap() def y = x x.put(3, 3) y.put(3, 3) return x != y"));
}
public void testNer() {
assertEquals(true, exec("def x = (byte)7 def y = (int)7 return x !== y"));
assertEquals(true, exec("def x = (short)6 def y = (int)6 return x !== y"));
assertEquals(true, exec("def x = (char)5 def y = (int)5 return x !== y"));
assertEquals(false, exec("def x = (int)4 def y = (int)4 return x !== y"));
assertEquals(true, exec("def x = (long)5 def y = (int)3 return x !== y"));
assertEquals(true, exec("def x = (float)6 def y = (int)2 return x !== y"));
assertEquals(true, exec("def x = (double)7 def y = (int)1 return x !== y"));
assertEquals(true, exec("def x = new HashMap() def y = new HashMap() return x !== y"));
assertEquals(true, exec("def x = new HashMap() x.put(3, 3) def y = new HashMap() return x !== y"));
assertEquals(true, exec("def x = new HashMap() x.put(3, 3) def y = new HashMap() y.put(3, 3) return x !== y"));
assertEquals(false, exec("def x = new HashMap() def y = x x.put(3, 3) y.put(3, 3) return x !== y"));
}
public void testLt() {
assertEquals(true, exec("def x = (byte)1 def y = (int)7 return x < y"));
assertEquals(true, exec("def x = (short)2 def y = (int)6 return x < y"));
assertEquals(true, exec("def x = (char)3 def y = (int)5 return x < y"));
assertEquals(false, exec("def x = (int)4 def y = (int)4 return x < y"));
assertEquals(false, exec("def x = (long)5 def y = (int)3 return x < y"));
assertEquals(false, exec("def x = (float)6 def y = (int)2 return x < y"));
assertEquals(false, exec("def x = (double)7 def y = (int)1 return x < y"));
assertEquals(true, exec("def x = (byte)1 def y = (double)7 return x < y"));
assertEquals(true, exec("def x = (short)2 def y = (double)6 return x < y"));
assertEquals(true, exec("def x = (char)3 def y = (double)5 return x < y"));
assertEquals(false, exec("def x = (int)4 def y = (double)4 return x < y"));
assertEquals(false, exec("def x = (long)5 def y = (double)3 return x < y"));
assertEquals(false, exec("def x = (float)6 def y = (double)2 return x < y"));
assertEquals(false, exec("def x = (double)7 def y = (double)1 return x < y"));
}
public void testLte() {
assertEquals(true, exec("def x = (byte)1 def y = (int)7 return x <= y"));
assertEquals(true, exec("def x = (short)2 def y = (int)6 return x <= y"));
assertEquals(true, exec("def x = (char)3 def y = (int)5 return x <= y"));
assertEquals(true, exec("def x = (int)4 def y = (int)4 return x <= y"));
assertEquals(false, exec("def x = (long)5 def y = (int)3 return x <= y"));
assertEquals(false, exec("def x = (float)6 def y = (int)2 return x <= y"));
assertEquals(false, exec("def x = (double)7 def y = (int)1 return x <= y"));
assertEquals(true, exec("def x = (byte)1 def y = (double)7 return x <= y"));
assertEquals(true, exec("def x = (short)2 def y = (double)6 return x <= y"));
assertEquals(true, exec("def x = (char)3 def y = (double)5 return x <= y"));
assertEquals(true, exec("def x = (int)4 def y = (double)4 return x <= y"));
assertEquals(false, exec("def x = (long)5 def y = (double)3 return x <= y"));
assertEquals(false, exec("def x = (float)6 def y = (double)2 return x <= y"));
assertEquals(false, exec("def x = (double)7 def y = (double)1 return x <= y"));
}
public void testGt() {
assertEquals(false, exec("def x = (byte)1 def y = (int)7 return x > y"));
assertEquals(false, exec("def x = (short)2 def y = (int)6 return x > y"));
assertEquals(false, exec("def x = (char)3 def y = (int)5 return x > y"));
assertEquals(false, exec("def x = (int)4 def y = (int)4 return x > y"));
assertEquals(true, exec("def x = (long)5 def y = (int)3 return x > y"));
assertEquals(true, exec("def x = (float)6 def y = (int)2 return x > y"));
assertEquals(true, exec("def x = (double)7 def y = (int)1 return x > y"));
assertEquals(false, exec("def x = (byte)1 def y = (double)7 return x > y"));
assertEquals(false, exec("def x = (short)2 def y = (double)6 return x > y"));
assertEquals(false, exec("def x = (char)3 def y = (double)5 return x > y"));
assertEquals(false, exec("def x = (int)4 def y = (double)4 return x > y"));
assertEquals(true, exec("def x = (long)5 def y = (double)3 return x > y"));
assertEquals(true, exec("def x = (float)6 def y = (double)2 return x > y"));
assertEquals(true, exec("def x = (double)7 def y = (double)1 return x > y"));
}
public void testGte() {
assertEquals(false, exec("def x = (byte)1 def y = (int)7 return x >= y"));
assertEquals(false, exec("def x = (short)2 def y = (int)6 return x >= y"));
assertEquals(false, exec("def x = (char)3 def y = (int)5 return x >= y"));
assertEquals(true, exec("def x = (int)4 def y = (int)4 return x >= y"));
assertEquals(true, exec("def x = (long)5 def y = (int)3 return x >= y"));
assertEquals(true, exec("def x = (float)6 def y = (int)2 return x >= y"));
assertEquals(true, exec("def x = (double)7 def y = (int)1 return x >= y"));
assertEquals(false, exec("def x = (byte)1 def y = (double)7 return x >= y"));
assertEquals(false, exec("def x = (short)2 def y = (double)6 return x >= y"));
assertEquals(false, exec("def x = (char)3 def y = (double)5 return x >= y"));
assertEquals(true, exec("def x = (int)4 def y = (double)4 return x >= y"));
assertEquals(true, exec("def x = (long)5 def y = (double)3 return x >= y"));
assertEquals(true, exec("def x = (float)6 def y = (double)2 return x >= y"));
assertEquals(true, exec("def x = (double)7 def y = (double)1 return x >= y"));
}
}

147
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/DivisionTests.java Normal file
View File

@ -0,0 +1,147 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
/** Tests for division operator across all types */
//TODO: NaN/Inf/overflow/...
public class DivisionTests extends ScriptTestCase {
// TODO: byte,short,char
public void testInt() throws Exception {
assertEquals(1/1, exec("int x = 1; int y = 1; return x/y;"));
assertEquals(2/3, exec("int x = 2; int y = 3; return x/y;"));
assertEquals(5/10, exec("int x = 5; int y = 10; return x/y;"));
assertEquals(10/1/2, exec("int x = 10; int y = 1; int z = 2; return x/y/z;"));
assertEquals((10/1)/2, exec("int x = 10; int y = 1; int z = 2; return (x/y)/z;"));
assertEquals(10/(4/2), exec("int x = 10; int y = 4; int z = 2; return x/(y/z);"));
assertEquals(10/1, exec("int x = 10; int y = 1; return x/y;"));
assertEquals(0/1, exec("int x = 0; int y = 1; return x/y;"));
}
public void testIntConst() throws Exception {
assertEquals(1/1, exec("return 1/1;"));
assertEquals(2/3, exec("return 2/3;"));
assertEquals(5/10, exec("return 5/10;"));
assertEquals(10/1/2, exec("return 10/1/2;"));
assertEquals((10/1)/2, exec("return (10/1)/2;"));
assertEquals(10/(4/2), exec("return 10/(4/2);"));
assertEquals(10/1, exec("return 10/1;"));
assertEquals(0/1, exec("return 0/1;"));
}
public void testLong() throws Exception {
assertEquals(1L/1L, exec("long x = 1; long y = 1; return x/y;"));
assertEquals(2L/3L, exec("long x = 2; long y = 3; return x/y;"));
assertEquals(5L/10L, exec("long x = 5; long y = 10; return x/y;"));
assertEquals(10L/1L/2L, exec("long x = 10; long y = 1; long z = 2; return x/y/z;"));
assertEquals((10L/1L)/2L, exec("long x = 10; long y = 1; long z = 2; return (x/y)/z;"));
assertEquals(10L/(4L/2L), exec("long x = 10; long y = 4; long z = 2; return x/(y/z);"));
assertEquals(10L/1L, exec("long x = 10; long y = 1; return x/y;"));
assertEquals(0L/1L, exec("long x = 0; long y = 1; return x/y;"));
}
public void testLongConst() throws Exception {
assertEquals(1L/1L, exec("return 1L/1L;"));
assertEquals(2L/3L, exec("return 2L/3L;"));
assertEquals(5L/10L, exec("return 5L/10L;"));
assertEquals(10L/1L/2L, exec("return 10L/1L/2L;"));
assertEquals((10L/1L)/2L, exec("return (10L/1L)/2L;"));
assertEquals(10L/(4L/2L), exec("return 10L/(4L/2L);"));
assertEquals(10L/1L, exec("return 10L/1L;"));
assertEquals(0L/1L, exec("return 0L/1L;"));
}
public void testFloat() throws Exception {
assertEquals(1F/1F, exec("float x = 1; float y = 1; return x/y;"));
assertEquals(2F/3F, exec("float x = 2; float y = 3; return x/y;"));
assertEquals(5F/10F, exec("float x = 5; float y = 10; return x/y;"));
assertEquals(10F/1F/2F, exec("float x = 10; float y = 1; float z = 2; return x/y/z;"));
assertEquals((10F/1F)/2F, exec("float x = 10; float y = 1; float z = 2; return (x/y)/z;"));
assertEquals(10F/(4F/2F), exec("float x = 10; float y = 4; float z = 2; return x/(y/z);"));
assertEquals(10F/1F, exec("float x = 10; float y = 1; return x/y;"));
assertEquals(0F/1F, exec("float x = 0; float y = 1; return x/y;"));
}
public void testFloatConst() throws Exception {
assertEquals(1F/1F, exec("return 1F/1F;"));
assertEquals(2F/3F, exec("return 2F/3F;"));
assertEquals(5F/10F, exec("return 5F/10F;"));
assertEquals(10F/1F/2F, exec("return 10F/1F/2F;"));
assertEquals((10F/1F)/2F, exec("return (10F/1F)/2F;"));
assertEquals(10F/(4F/2F), exec("return 10F/(4F/2F);"));
assertEquals(10F/1F, exec("return 10F/1F;"));
assertEquals(0F/1F, exec("return 0F/1F;"));
}
public void testDouble() throws Exception {
assertEquals(1.0/1.0, exec("double x = 1; double y = 1; return x/y;"));
assertEquals(2.0/3.0, exec("double x = 2; double y = 3; return x/y;"));
assertEquals(5.0/10.0, exec("double x = 5; double y = 10; return x/y;"));
assertEquals(10.0/1.0/2.0, exec("double x = 10; double y = 1; double z = 2; return x/y/z;"));
assertEquals((10.0/1.0)/2.0, exec("double x = 10; double y = 1; double z = 2; return (x/y)/z;"));
assertEquals(10.0/(4.0/2.0), exec("double x = 10; double y = 4; double z = 2; return x/(y/z);"));
assertEquals(10.0/1.0, exec("double x = 10; double y = 1; return x/y;"));
assertEquals(0.0/1.0, exec("double x = 0; double y = 1; return x/y;"));
}
public void testDoubleConst() throws Exception {
assertEquals(1.0/1.0, exec("return 1.0/1.0;"));
assertEquals(2.0/3.0, exec("return 2.0/3.0;"));
assertEquals(5.0/10.0, exec("return 5.0/10.0;"));
assertEquals(10.0/1.0/2.0, exec("return 10.0/1.0/2.0;"));
assertEquals((10.0/1.0)/2.0, exec("return (10.0/1.0)/2.0;"));
assertEquals(10.0/(4.0/2.0), exec("return 10.0/(4.0/2.0);"));
assertEquals(10.0/1.0, exec("return 10.0/1.0;"));
assertEquals(0.0/1.0, exec("return 0.0/1.0;"));
}
public void testDivideByZero() throws Exception {
try {
exec("int x = 1; int y = 0; return x / y;");
fail("should have hit exception");
} catch (ArithmeticException expected) {
// divide by zero
}
try {
exec("long x = 1L; long y = 0L; return x / y;");
fail("should have hit exception");
} catch (ArithmeticException expected) {
// divide by zero
}
}
public void testDivideByZeroConst() throws Exception {
try {
exec("return 1/0;");
fail("should have hit exception");
} catch (ArithmeticException expected) {
// divide by zero
}
try {
exec("return 1L/0L;");
fail("should have hit exception");
} catch (ArithmeticException expected) {
// divide by zero
}
}
}

184
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/EqualsTests.java Normal file
View File

@ -0,0 +1,184 @@
package org.elasticsearch.plan.a;
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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.
*/
// TODO: Figure out a way to test autobox caching properly from methods such as Integer.valueOf(int);
public class EqualsTests extends ScriptTestCase {
public void testTypesEquals() {
assertEquals(true, exec("return false === false;"));
assertEquals(true, exec("boolean x = false; boolean y = false; return x === y;"));
assertEquals(false, exec("return (byte)3 === (byte)4;"));
assertEquals(true, exec("byte x = 3; byte y = 3; return x === y;"));
assertEquals(false, exec("return (char)3 === (char)4;"));
assertEquals(true, exec("char x = 3; char y = 3; return x === y;"));
assertEquals(false, exec("return (short)3 === (short)4;"));
assertEquals(true, exec("short x = 3; short y = 3; return x === y;"));
assertEquals(false, exec("return (int)3 === (int)4;"));
assertEquals(true, exec("int x = 3; int y = 3; return x === y;"));
assertEquals(false, exec("return (long)3 === (long)4;"));
assertEquals(true, exec("long x = 3; long y = 3; return x === y;"));
assertEquals(false, exec("return (float)3 === (float)4;"));
assertEquals(true, exec("float x = 3; float y = 3; return x === y;"));
assertEquals(false, exec("return (double)3 === (double)4;"));
assertEquals(true, exec("double x = 3; double y = 3; return x === y;"));
assertEquals(true, exec("return false == false;"));
assertEquals(true, exec("boolean x = false; boolean y = false; return x == y;"));
assertEquals(false, exec("return (byte)3 == (byte)4;"));
assertEquals(true, exec("byte x = 3; byte y = 3; return x == y;"));
assertEquals(false, exec("return (char)3 == (char)4;"));
assertEquals(true, exec("char x = 3; char y = 3; return x == y;"));
assertEquals(false, exec("return (short)3 == (short)4;"));
assertEquals(true, exec("short x = 3; short y = 3; return x == y;"));
assertEquals(false, exec("return (int)3 == (int)4;"));
assertEquals(true, exec("int x = 3; int y = 3; return x == y;"));
assertEquals(false, exec("return (long)3 == (long)4;"));
assertEquals(true, exec("long x = 3; long y = 3; return x == y;"));
assertEquals(false, exec("return (float)3 == (float)4;"));
assertEquals(true, exec("float x = 3; float y = 3; return x == y;"));
assertEquals(false, exec("return (double)3 == (double)4;"));
assertEquals(true, exec("double x = 3; double y = 3; return x == y;"));
}
public void testTypesNotEquals() {
assertEquals(false, exec("return true !== true;"));
assertEquals(false, exec("boolean x = false; boolean y = false; return x !== y;"));
assertEquals(true, exec("return (byte)3 !== (byte)4;"));
assertEquals(false, exec("byte x = 3; byte y = 3; return x !== y;"));
assertEquals(true, exec("return (char)3 !== (char)4;"));
assertEquals(false, exec("char x = 3; char y = 3; return x !== y;"));
assertEquals(true, exec("return (short)3 !== (short)4;"));
assertEquals(false, exec("short x = 3; short y = 3; return x !== y;"));
assertEquals(true, exec("return (int)3 !== (int)4;"));
assertEquals(false, exec("int x = 3; int y = 3; return x !== y;"));
assertEquals(true, exec("return (long)3 !== (long)4;"));
assertEquals(false, exec("long x = 3; long y = 3; return x !== y;"));
assertEquals(true, exec("return (float)3 !== (float)4;"));
assertEquals(false, exec("float x = 3; float y = 3; return x !== y;"));
assertEquals(true, exec("return (double)3 !== (double)4;"));
assertEquals(false, exec("double x = 3; double y = 3; return x !== y;"));
assertEquals(false, exec("return true != true;"));
assertEquals(false, exec("boolean x = false; boolean y = false; return x != y;"));
assertEquals(true, exec("return (byte)3 != (byte)4;"));
assertEquals(false, exec("byte x = 3; byte y = 3; return x != y;"));
assertEquals(true, exec("return (char)3 != (char)4;"));
assertEquals(false, exec("char x = 3; char y = 3; return x != y;"));
assertEquals(true, exec("return (short)3 != (short)4;"));
assertEquals(false, exec("short x = 3; short y = 3; return x != y;"));
assertEquals(true, exec("return (int)3 != (int)4;"));
assertEquals(false, exec("int x = 3; int y = 3; return x != y;"));
assertEquals(true, exec("return (long)3 != (long)4;"));
assertEquals(false, exec("long x = 3; long y = 3; return x != y;"));
assertEquals(true, exec("return (float)3 != (float)4;"));
assertEquals(false, exec("float x = 3; float y = 3; return x != y;"));
assertEquals(true, exec("return (double)3 != (double)4;"));
assertEquals(false, exec("double x = 3; double y = 3; return x != y;"));
}
public void testEquals() {
assertEquals(true, exec("return new Long(3) == new Long(3);"));
assertEquals(false, exec("return new Long(3) === new Long(3);"));
assertEquals(true, exec("Integer x = new Integer(3); Object y = x; return x == y;"));
assertEquals(true, exec("Integer x = new Integer(3); Object y = x; return x === y;"));
assertEquals(true, exec("Integer x = new Integer(3); Object y = new Integer(3); return x == y;"));
assertEquals(false, exec("Integer x = new Integer(3); Object y = new Integer(3); return x === y;"));
assertEquals(true, exec("Integer x = new Integer(3); int y = 3; return x == y;"));
assertEquals(true, exec("Integer x = new Integer(3); short y = 3; return x == y;"));
assertEquals(true, exec("Integer x = new Integer(3); Short y = (short)3; return x == y;"));
assertEquals(false, exec("Integer x = new Integer(3); int y = 3; return x === y;"));
assertEquals(false, exec("Integer x = new Integer(3); double y = 3; return x === y;"));
assertEquals(true, exec("int[] x = new int[1]; Object y = x; return x == y;"));
assertEquals(true, exec("int[] x = new int[1]; Object y = x; return x === y;"));
assertEquals(false, exec("int[] x = new int[1]; Object y = new int[1]; return x == y;"));
assertEquals(false, exec("int[] x = new int[1]; Object y = new int[1]; return x === y;"));
assertEquals(false, exec("Map x = new HashMap(); List y = new ArrayList(); return x == y;"));
assertEquals(false, exec("Map x = new HashMap(); List y = new ArrayList(); return x === y;"));
}
public void testNotEquals() {
assertEquals(false, exec("return new Long(3) != new Long(3);"));
assertEquals(true, exec("return new Long(3) !== new Long(3);"));
assertEquals(false, exec("Integer x = new Integer(3); Object y = x; return x != y;"));
assertEquals(false, exec("Integer x = new Integer(3); Object y = x; return x !== y;"));
assertEquals(false, exec("Integer x = new Integer(3); Object y = new Integer(3); return x != y;"));
assertEquals(true, exec("Integer x = new Integer(3); Object y = new Integer(3); return x !== y;"));
assertEquals(true, exec("Integer x = new Integer(3); int y = 3; return x !== y;"));
assertEquals(true, exec("Integer x = new Integer(3); double y = 3; return x !== y;"));
assertEquals(false, exec("int[] x = new int[1]; Object y = x; return x != y;"));
assertEquals(false, exec("int[] x = new int[1]; Object y = x; return x !== y;"));
assertEquals(true, exec("int[] x = new int[1]; Object y = new int[1]; return x != y;"));
assertEquals(true, exec("int[] x = new int[1]; Object y = new int[1]; return x !== y;"));
assertEquals(true, exec("Map x = new HashMap(); List y = new ArrayList(); return x != y;"));
assertEquals(true, exec("Map x = new HashMap(); List y = new ArrayList(); return x !== y;"));
}
public void testBranchEquals() {
assertEquals(0, exec("Character a = 'a'; Character b = 'b'; if (a == b) return 1; else return 0;"));
assertEquals(1, exec("Character a = 'a'; Character b = 'a'; if (a == b) return 1; else return 0;"));
assertEquals(0, exec("Integer a = new Integer(1); Integer b = 1; if (a === b) return 1; else return 0;"));
assertEquals(0, exec("Character a = 'a'; Character b = new Character('a'); if (a === b) return 1; else return 0;"));
assertEquals(1, exec("Character a = 'a'; Object b = a; if (a === b) return 1; else return 0;"));
assertEquals(1, exec("Integer a = 1; Number b = a; Number c = a; if (c === b) return 1; else return 0;"));
assertEquals(0, exec("Integer a = 1; Character b = 'a'; if (a === (Object)b) return 1; else return 0;"));
}
public void testBranchNotEquals() {
assertEquals(1, exec("Character a = 'a'; Character b = 'b'; if (a != b) return 1; else return 0;"));
assertEquals(0, exec("Character a = 'a'; Character b = 'a'; if (a != b) return 1; else return 0;"));
assertEquals(1, exec("Integer a = new Integer(1); Integer b = 1; if (a !== b) return 1; else return 0;"));
assertEquals(1, exec("Character a = 'a'; Character b = new Character('a'); if (a !== b) return 1; else return 0;"));
assertEquals(0, exec("Character a = 'a'; Object b = a; if (a !== b) return 1; else return 0;"));
assertEquals(0, exec("Integer a = 1; Number b = a; Number c = a; if (c !== b) return 1; else return 0;"));
assertEquals(1, exec("Integer a = 1; Character b = 'a'; if (a !== (Object)b) return 1; else return 0;"));
}
public void testRightHandNull() {
assertEquals(false, exec("Character a = 'a'; return a == null;"));
assertEquals(false, exec("Character a = 'a'; return a === null;"));
assertEquals(true, exec("Character a = 'a'; return a != null;"));
assertEquals(true, exec("Character a = 'a'; return a !== null;"));
assertEquals(true, exec("Character a = null; return a == null;"));
assertEquals(false, exec("Character a = null; return a != null;"));
assertEquals(false, exec("Character a = 'a'; Character b = null; return a == b;"));
assertEquals(true, exec("Character a = null; Character b = null; return a === b;"));
assertEquals(true, exec("Character a = 'a'; Character b = null; return a != b;"));
assertEquals(false, exec("Character a = null; Character b = null; return a !== b;"));
assertEquals(false, exec("Integer x = null; double y = 2.0; return x == y;"));
assertEquals(true, exec("Integer x = null; Short y = null; return x == y;"));
}
public void testLeftHandNull() {
assertEquals(false, exec("Character a = 'a'; return null == a;"));
assertEquals(false, exec("Character a = 'a'; return null === a;"));
assertEquals(true, exec("Character a = 'a'; return null != a;"));
assertEquals(true, exec("Character a = 'a'; return null !== a;"));
assertEquals(true, exec("Character a = null; return null == a;"));
assertEquals(false, exec("Character a = null; return null != a;"));
assertEquals(false, exec("Character a = null; Character b = 'a'; return a == b;"));
assertEquals(true, exec("Character a = null; Character b = null; return a == b;"));
assertEquals(true, exec("Character a = null; Character b = null; return b === a;"));
assertEquals(true, exec("Character a = null; Character b = 'a'; return a != b;"));
assertEquals(false, exec("Character a = null; Character b = null; return b != a;"));
assertEquals(false, exec("Character a = null; Character b = null; return b !== a;"));
assertEquals(false, exec("Integer x = null; double y = 2.0; return y == x;"));
assertEquals(true, exec("Integer x = null; Short y = null; return y == x;"));
}
}

108
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/FieldTests.java Normal file
View File

@ -0,0 +1,108 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import org.junit.Before;
public class FieldTests extends ScriptTestCase {
public static class FieldClass {
public boolean z = false;
public byte b = 0;
public short s = 1;
public char c = 'c';
public int i = 2;
public int si = -1;
public long j = 3l;
public float f = 4.0f;
public double d = 5.0;
public String t = "s";
public Object l = new Object();
public float test(float a, float b) {
return Math.min(a, b);
}
public int getSi() {
return si;
}
public void setSi(final int si) {
this.si = si;
}
}
public static class FieldDefinition extends Definition {
FieldDefinition() {
super();
addStruct("FieldClass", FieldClass.class);
addConstructor("FieldClass", "new", new Type[] {}, null);
addField("FieldClass", "z", null, false, booleanType, null);
addField("FieldClass", "b", null, false, byteType, null);
addField("FieldClass", "s", null, false, shortType, null);
addField("FieldClass", "c", null, false, charType, null);
addField("FieldClass", "i", null, false, intType, null);
addField("FieldClass", "j", null, false, longType, null);
addField("FieldClass", "f", null, false, floatType, null);
addField("FieldClass", "d", null, false, doubleType, null);
addField("FieldClass", "t", null, false, stringType, null);
addField("FieldClass", "l", null, false, objectType, null);
addClass("FieldClass");
addMethod("FieldClass", "getSi", null, false, intType, new Type[] {}, null, null);
addMethod("FieldClass", "setSi", null, false, voidType, new Type[] {intType}, null, null);
addMethod("FieldClass", "test", null, false, floatType, new Type[] {floatType, floatType}, null, null);
}
}
@Before
public void setDefinition() {
scriptEngine.setDefinition(new FieldDefinition());
}
public void testIntField() {
assertEquals("s5t42", exec("def fc = new FieldClass() return fc.t += 2 + fc.j + \"t\" + 4 + (3 - 1)"));
assertEquals(2.0f, exec("def fc = new FieldClass(); def l = new Double(3) Byte b = new Byte((byte)2) return fc.test(l, b)"));
assertEquals(4, exec("def fc = new FieldClass() fc.i = 4 return fc.i"));
assertEquals(5, exec("FieldClass fc0 = new FieldClass() FieldClass fc1 = new FieldClass() fc0.i = 7 - fc0.i fc1.i = fc0.i return fc1.i"));
assertEquals(8, exec("def fc0 = new FieldClass() def fc1 = new FieldClass() fc0.i += fc1.i fc0.i += fc0.i return fc0.i"));
}
public void testExplicitShortcut() {
assertEquals(5, exec("FieldClass fc = new FieldClass() fc.setSi(5) return fc.si"));
assertEquals(-1, exec("FieldClass fc = new FieldClass() def x = fc.getSi() x"));
assertEquals(5, exec("FieldClass fc = new FieldClass() fc.si = 5 return fc.si"));
assertEquals(0, exec("FieldClass fc = new FieldClass() fc.si++ return fc.si"));
assertEquals(-1, exec("FieldClass fc = new FieldClass() def x = fc.si++ return x"));
assertEquals(0, exec("FieldClass fc = new FieldClass() def x = ++fc.si return x"));
assertEquals(-2, exec("FieldClass fc = new FieldClass() fc.si *= 2 fc.si"));
assertEquals("-1test", exec("FieldClass fc = new FieldClass() fc.si + \"test\""));
}
public void testImplicitShortcut() {
assertEquals(5, exec("def fc = new FieldClass() fc.setSi(5) return fc.si"));
assertEquals(-1, exec("def fc = new FieldClass() def x = fc.getSi() x"));
assertEquals(5, exec("def fc = new FieldClass() fc.si = 5 return fc.si"));
assertEquals(0, exec("def fc = new FieldClass() fc.si++ return fc.si"));
assertEquals(-1, exec("def fc = new FieldClass() def x = fc.si++ return x"));
assertEquals(0, exec("def fc = new FieldClass() def x = ++fc.si return x"));
assertEquals(-2, exec("def fc = new FieldClass() fc.si *= 2 fc.si"));
assertEquals("-1test", exec("def fc = new FieldClass() fc.si + \"test\""));
}
}

294
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/FloatOverflowDisabledTests.java Normal file
View File

@ -0,0 +1,294 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import org.elasticsearch.common.settings.Settings;
/** Tests floating point overflow with numeric overflow disabled */
public class FloatOverflowDisabledTests extends ScriptTestCase {
@Override
protected Settings getSettings() {
Settings.Builder builder = Settings.builder();
builder.put(super.getSettings());
builder.put(PlanAScriptEngineService.NUMERIC_OVERFLOW, false);
return builder.build();
}
public void testAssignmentAdditionOverflow() {
// float
try {
exec("float x = 3.4028234663852886E38f; x += 3.4028234663852886E38f; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("float x = -3.4028234663852886E38f; x += -3.4028234663852886E38f; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
// double
try {
exec("double x = 1.7976931348623157E308; x += 1.7976931348623157E308; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("double x = -1.7976931348623157E308; x += -1.7976931348623157E308; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
}
public void testAssignmentSubtractionOverflow() {
// float
try {
exec("float x = 3.4028234663852886E38f; x -= -3.4028234663852886E38f; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("float x = -3.4028234663852886E38f; x -= 3.4028234663852886E38f; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
// double
try {
exec("double x = 1.7976931348623157E308; x -= -1.7976931348623157E308; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("double x = -1.7976931348623157E308; x -= 1.7976931348623157E308; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
}
public void testAssignmentMultiplicationOverflow() {
// float
try {
exec("float x = 3.4028234663852886E38f; x *= 3.4028234663852886E38f; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("float x = 3.4028234663852886E38f; x *= -3.4028234663852886E38f; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
// double
try {
exec("double x = 1.7976931348623157E308; x *= 1.7976931348623157E308; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("double x = 1.7976931348623157E308; x *= -1.7976931348623157E308; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
}
public void testAssignmentDivisionOverflow() {
// float
try {
exec("float x = 3.4028234663852886E38f; x /= 1.401298464324817E-45f; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("float x = 3.4028234663852886E38f; x /= -1.401298464324817E-45f; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("float x = 1.0f; x /= 0.0f; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
// double
try {
exec("double x = 1.7976931348623157E308; x /= 4.9E-324; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("double x = 1.7976931348623157E308; x /= -4.9E-324; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("double x = 1.0f; x /= 0.0; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
}
public void testAddition() throws Exception {
try {
exec("float x = 3.4028234663852886E38f; float y = 3.4028234663852886E38f; return x + y;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("double x = 1.7976931348623157E308; double y = 1.7976931348623157E308; return x + y;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
}
public void testAdditionConst() throws Exception {
try {
exec("return 3.4028234663852886E38f + 3.4028234663852886E38f;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("return 1.7976931348623157E308 + 1.7976931348623157E308;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
}
public void testSubtraction() throws Exception {
try {
exec("float x = -3.4028234663852886E38f; float y = 3.4028234663852886E38f; return x - y;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("double x = -1.7976931348623157E308; double y = 1.7976931348623157E308; return x - y;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
}
public void testSubtractionConst() throws Exception {
try {
exec("return -3.4028234663852886E38f - 3.4028234663852886E38f;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("return -1.7976931348623157E308 - 1.7976931348623157E308;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
}
public void testMultiplication() throws Exception {
try {
exec("float x = 3.4028234663852886E38f; float y = 3.4028234663852886E38f; return x * y;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("double x = 1.7976931348623157E308; double y = 1.7976931348623157E308; return x * y;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
}
public void testMultiplicationConst() throws Exception {
try {
exec("return 3.4028234663852886E38f * 3.4028234663852886E38f;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("return 1.7976931348623157E308 * 1.7976931348623157E308;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
}
public void testDivision() throws Exception {
try {
exec("float x = 3.4028234663852886E38f; float y = 1.401298464324817E-45f; return x / y;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("float x = 1.0f; float y = 0.0f; return x / y;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("double x = 1.7976931348623157E308; double y = 4.9E-324; return x / y;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("double x = 1.0; double y = 0.0; return x / y;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
}
public void testDivisionConst() throws Exception {
try {
exec("return 3.4028234663852886E38f / 1.401298464324817E-45f;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("return 1.0f / 0.0f;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("return 1.7976931348623157E308 / 4.9E-324;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("return 1.0 / 0.0;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
}
public void testDivisionNaN() throws Exception {
// float division, constant division, and assignment
try {
exec("float x = 0f; float y = 0f; return x / y;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("return 0f / 0f;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("float x = 0f; x /= 0f; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
// double division, constant division, and assignment
try {
exec("double x = 0.0; double y = 0.0; return x / y;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("return 0.0 / 0.0;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("double x = 0.0; x /= 0.0; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
}
public void testRemainderNaN() throws Exception {
// float division, constant division, and assignment
try {
exec("float x = 1f; float y = 0f; return x % y;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("return 1f % 0f;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("float x = 1f; x %= 0f; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
// double division, constant division, and assignment
try {
exec("double x = 1.0; double y = 0.0; return x % y;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("return 1.0 % 0.0;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
try {
exec("double x = 1.0; x %= 0.0; return x;");
fail("didn't hit expected exception");
} catch (ArithmeticException expected) {}
}
}

144
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/FloatOverflowEnabledTests.java Normal file
View File

@ -0,0 +1,144 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import org.elasticsearch.common.settings.Settings;
/** Tests floating point overflow with numeric overflow enabled */
public class FloatOverflowEnabledTests extends ScriptTestCase {
@Override
protected Settings getSettings() {
Settings.Builder builder = Settings.builder();
builder.put(super.getSettings());
builder.put(PlanAScriptEngineService.NUMERIC_OVERFLOW, true);
return builder.build();
}
public void testAssignmentAdditionOverflow() {
// float
assertEquals(Float.POSITIVE_INFINITY, exec("float x = 3.4028234663852886E38f; x += 3.4028234663852886E38f; return x;"));
assertEquals(Float.NEGATIVE_INFINITY, exec("float x = -3.4028234663852886E38f; x += -3.4028234663852886E38f; return x;"));
// double
assertEquals(Double.POSITIVE_INFINITY, exec("double x = 1.7976931348623157E308; x += 1.7976931348623157E308; return x;"));
assertEquals(Double.NEGATIVE_INFINITY, exec("double x = -1.7976931348623157E308; x += -1.7976931348623157E308; return x;"));
}
public void testAssignmentSubtractionOverflow() {
// float
assertEquals(Float.POSITIVE_INFINITY, exec("float x = 3.4028234663852886E38f; x -= -3.4028234663852886E38f; return x;"));
assertEquals(Float.NEGATIVE_INFINITY, exec("float x = -3.4028234663852886E38f; x -= 3.4028234663852886E38f; return x;"));
// double
assertEquals(Double.POSITIVE_INFINITY, exec("double x = 1.7976931348623157E308; x -= -1.7976931348623157E308; return x;"));
assertEquals(Double.NEGATIVE_INFINITY, exec("double x = -1.7976931348623157E308; x -= 1.7976931348623157E308; return x;"));
}
public void testAssignmentMultiplicationOverflow() {
// float
assertEquals(Float.POSITIVE_INFINITY, exec("float x = 3.4028234663852886E38f; x *= 3.4028234663852886E38f; return x;"));
assertEquals(Float.NEGATIVE_INFINITY, exec("float x = 3.4028234663852886E38f; x *= -3.4028234663852886E38f; return x;"));
// double
assertEquals(Double.POSITIVE_INFINITY, exec("double x = 1.7976931348623157E308; x *= 1.7976931348623157E308; return x;"));
assertEquals(Double.NEGATIVE_INFINITY, exec("double x = 1.7976931348623157E308; x *= -1.7976931348623157E308; return x;"));
}
public void testAssignmentDivisionOverflow() {
// float
assertEquals(Float.POSITIVE_INFINITY, exec("float x = 3.4028234663852886E38f; x /= 1.401298464324817E-45f; return x;"));
assertEquals(Float.NEGATIVE_INFINITY, exec("float x = 3.4028234663852886E38f; x /= -1.401298464324817E-45f; return x;"));
assertEquals(Float.POSITIVE_INFINITY, exec("float x = 1.0f; x /= 0.0f; return x;"));
// double
assertEquals(Double.POSITIVE_INFINITY, exec("double x = 1.7976931348623157E308; x /= 4.9E-324; return x;"));
assertEquals(Double.NEGATIVE_INFINITY, exec("double x = 1.7976931348623157E308; x /= -4.9E-324; return x;"));
assertEquals(Double.POSITIVE_INFINITY, exec("double x = 1.0f; x /= 0.0; return x;"));
}
public void testAddition() throws Exception {
assertEquals(Float.POSITIVE_INFINITY, exec("float x = 3.4028234663852886E38f; float y = 3.4028234663852886E38f; return x + y;"));
assertEquals(Double.POSITIVE_INFINITY, exec("double x = 1.7976931348623157E308; double y = 1.7976931348623157E308; return x + y;"));
}
public void testAdditionConst() throws Exception {
assertEquals(Float.POSITIVE_INFINITY, exec("return 3.4028234663852886E38f + 3.4028234663852886E38f;"));
assertEquals(Double.POSITIVE_INFINITY, exec("return 1.7976931348623157E308 + 1.7976931348623157E308;"));
}
public void testSubtraction() throws Exception {
assertEquals(Float.NEGATIVE_INFINITY, exec("float x = -3.4028234663852886E38f; float y = 3.4028234663852886E38f; return x - y;"));
assertEquals(Double.NEGATIVE_INFINITY, exec("double x = -1.7976931348623157E308; double y = 1.7976931348623157E308; return x - y;"));
}
public void testSubtractionConst() throws Exception {
assertEquals(Float.NEGATIVE_INFINITY, exec("return -3.4028234663852886E38f - 3.4028234663852886E38f;"));
assertEquals(Double.NEGATIVE_INFINITY, exec("return -1.7976931348623157E308 - 1.7976931348623157E308;"));
}
public void testMultiplication() throws Exception {
assertEquals(Float.POSITIVE_INFINITY, exec("float x = 3.4028234663852886E38f; float y = 3.4028234663852886E38f; return x * y;"));
assertEquals(Double.POSITIVE_INFINITY, exec("double x = 1.7976931348623157E308; double y = 1.7976931348623157E308; return x * y;"));
}
public void testMultiplicationConst() throws Exception {
assertEquals(Float.POSITIVE_INFINITY, exec("return 3.4028234663852886E38f * 3.4028234663852886E38f;"));
assertEquals(Double.POSITIVE_INFINITY, exec("return 1.7976931348623157E308 * 1.7976931348623157E308;"));
}
public void testDivision() throws Exception {
assertEquals(Float.POSITIVE_INFINITY, exec("float x = 3.4028234663852886E38f; float y = 1.401298464324817E-45f; return x / y;"));
assertEquals(Float.POSITIVE_INFINITY, exec("float x = 1.0f; float y = 0.0f; return x / y;"));
assertEquals(Double.POSITIVE_INFINITY, exec("double x = 1.7976931348623157E308; double y = 4.9E-324; return x / y;"));
assertEquals(Double.POSITIVE_INFINITY, exec("double x = 1.0; double y = 0.0; return x / y;"));
}
public void testDivisionConst() throws Exception {
assertEquals(Float.POSITIVE_INFINITY, exec("return 3.4028234663852886E38f / 1.401298464324817E-45f;"));
assertEquals(Float.POSITIVE_INFINITY, exec("return 1.0f / 0.0f;"));
assertEquals(Double.POSITIVE_INFINITY, exec("return 1.7976931348623157E308 / 4.9E-324;"));
assertEquals(Double.POSITIVE_INFINITY, exec("return 1.0 / 0.0;"));
}
public void testDivisionNaN() throws Exception {
// float division, constant division, and assignment
assertTrue(Float.isNaN((Float) exec("float x = 0f; float y = 0f; return x / y;")));
assertTrue(Float.isNaN((Float) exec("return 0f / 0f;")));
assertTrue(Float.isNaN((Float) exec("float x = 0f; x /= 0f; return x;")));
// double division, constant division, and assignment
assertTrue(Double.isNaN((Double) exec("double x = 0.0; double y = 0.0; return x / y;")));
assertTrue(Double.isNaN((Double) exec("return 0.0 / 0.0;")));
assertTrue(Double.isNaN((Double) exec("double x = 0.0; x /= 0.0; return x;")));
}
public void testRemainderNaN() throws Exception {
// float division, constant division, and assignment
assertTrue(Float.isNaN((Float) exec("float x = 1f; float y = 0f; return x % y;")));
assertTrue(Float.isNaN((Float) exec("return 1f % 0f;")));
assertTrue(Float.isNaN((Float) exec("float x = 1f; x %= 0f; return x;")));
// double division, constant division, and assignment
assertTrue(Double.isNaN((Double) exec("double x = 1.0; double y = 0.0; return x % y;")));
assertTrue(Double.isNaN((Double) exec("return 1.0 % 0.0;")));
assertTrue(Double.isNaN((Double) exec("double x = 1.0; x %= 0.0; return x;")));
}
}

79
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/IncrementTests.java Normal file
View File

@ -0,0 +1,79 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
/** Tests for increment/decrement operators across all data types */
public class IncrementTests extends ScriptTestCase {
/** incrementing byte values */
public void testIncrementByte() {
assertEquals((byte)0, exec("byte x = (byte)0; return x++;"));
assertEquals((byte)0, exec("byte x = (byte)0; return x--;"));
assertEquals((byte)1, exec("byte x = (byte)0; return ++x;"));
assertEquals((byte)-1, exec("byte x = (byte)0; return --x;"));
}
/** incrementing char values */
public void testIncrementChar() {
assertEquals((char)0, exec("char x = (char)0; return x++;"));
assertEquals((char)1, exec("char x = (char)1; return x--;"));
assertEquals((char)1, exec("char x = (char)0; return ++x;"));
}
/** incrementing short values */
public void testIncrementShort() {
assertEquals((short)0, exec("short x = (short)0; return x++;"));
assertEquals((short)0, exec("short x = (short)0; return x--;"));
assertEquals((short)1, exec("short x = (short)0; return ++x;"));
assertEquals((short)-1, exec("short x = (short)0; return --x;"));
}
/** incrementing integer values */
public void testIncrementInt() {
assertEquals(0, exec("int x = 0; return x++;"));
assertEquals(0, exec("int x = 0; return x--;"));
assertEquals(1, exec("int x = 0; return ++x;"));
assertEquals(-1, exec("int x = 0; return --x;"));
}
/** incrementing long values */
public void testIncrementLong() {
assertEquals(0L, exec("long x = 0; return x++;"));
assertEquals(0L, exec("long x = 0; return x--;"));
assertEquals(1L, exec("long x = 0; return ++x;"));
assertEquals(-1L, exec("long x = 0; return --x;"));
}
/** incrementing float values */
public void testIncrementFloat() {
assertEquals(0F, exec("float x = 0F; return x++;"));
assertEquals(0F, exec("float x = 0F; return x--;"));
assertEquals(1F, exec("float x = 0F; return ++x;"));
assertEquals(-1F, exec("float x = 0F; return --x;"));
}
/** incrementing double values */
public void testIncrementDouble() {
assertEquals(0D, exec("double x = 0.0; return x++;"));
assertEquals(0D, exec("double x = 0.0; return x--;"));
assertEquals(1D, exec("double x = 0.0; return ++x;"));
assertEquals(-1D, exec("double x = 0.0; return --x;"));
}
}

445
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/IntegerOverflowDisabledTests.java Normal file
View File

@ -0,0 +1,445 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import org.elasticsearch.common.settings.Settings;
/** Tests integer overflow with numeric overflow disabled */
public class IntegerOverflowDisabledTests extends ScriptTestCase {
@Override
protected Settings getSettings() {
Settings.Builder builder = Settings.builder();
builder.put(super.getSettings());
builder.put(PlanAScriptEngineService.NUMERIC_OVERFLOW, false);
return builder.build();
}
public void testAssignmentAdditionOverflow() {
// byte
try {
exec("byte x = 0; x += 128; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("byte x = 0; x += -129; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
// short
try {
exec("short x = 0; x += 32768; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("byte x = 0; x += -32769; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
// char
try {
exec("char x = 0; x += 65536; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("char x = 0; x += -65536; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
// int
try {
exec("int x = 1; x += 2147483647; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("int x = -2; x += -2147483647; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
// long
try {
exec("long x = 1; x += 9223372036854775807L; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("long x = -2; x += -9223372036854775807L; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testAssignmentSubtractionOverflow() {
// byte
try {
exec("byte x = 0; x -= -128; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("byte x = 0; x -= 129; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
// short
try {
exec("short x = 0; x -= -32768; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("byte x = 0; x -= 32769; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
// char
try {
exec("char x = 0; x -= -65536; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("char x = 0; x -= 65536; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
// int
try {
exec("int x = 1; x -= -2147483647; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("int x = -2; x -= 2147483647; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
// long
try {
exec("long x = 1; x -= -9223372036854775807L; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("long x = -2; x -= 9223372036854775807L; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testAssignmentMultiplicationOverflow() {
// byte
try {
exec("byte x = 2; x *= 128; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("byte x = 2; x *= -128; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
// char
try {
exec("char x = 2; x *= 65536; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("char x = 2; x *= -65536; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
// int
try {
exec("int x = 2; x *= 2147483647; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("int x = 2; x *= -2147483647; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
// long
try {
exec("long x = 2; x *= 9223372036854775807L; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("long x = 2; x *= -9223372036854775807L; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testAssignmentDivisionOverflow() {
// byte
try {
exec("byte x = (byte) -128; x /= -1; return x;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
// short
try {
exec("short x = (short) -32768; x /= -1; return x;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
// cannot happen for char: unsigned
// int
try {
exec("int x = -2147483647 - 1; x /= -1; return x;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
// long
try {
exec("long x = -9223372036854775807L - 1L; x /=-1L; return x;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
}
public void testIncrementOverFlow() throws Exception {
// byte
try {
exec("byte x = 127; ++x; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("byte x = 127; x++; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("byte x = (byte) -128; --x; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("byte x = (byte) -128; x--; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
// short
try {
exec("short x = 32767; ++x; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("short x = 32767; x++; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("short x = (short) -32768; --x; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("short x = (short) -32768; x--; return x;");
} catch (ArithmeticException expected) {}
// char
try {
exec("char x = 65535; ++x; return x;");
} catch (ArithmeticException expected) {}
try {
exec("char x = 65535; x++; return x;");
} catch (ArithmeticException expected) {}
try {
exec("char x = (char) 0; --x; return x;");
} catch (ArithmeticException expected) {}
try {
exec("char x = (char) 0; x--; return x;");
} catch (ArithmeticException expected) {}
// int
try {
exec("int x = 2147483647; ++x; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("int x = 2147483647; x++; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("int x = (int) -2147483648L; --x; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("int x = (int) -2147483648L; x--; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
// long
try {
exec("long x = 9223372036854775807L; ++x; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("long x = 9223372036854775807L; x++; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("long x = -9223372036854775807L - 1L; --x; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("long x = -9223372036854775807L - 1L; x--; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testAddition() throws Exception {
try {
exec("int x = 2147483647; int y = 2147483647; return x + y;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
try {
exec("long x = 9223372036854775807L; long y = 9223372036854775807L; return x + y;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
}
public void testAdditionConst() throws Exception {
try {
exec("return 2147483647 + 2147483647;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
try {
exec("return 9223372036854775807L + 9223372036854775807L;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
}
public void testSubtraction() throws Exception {
try {
exec("int x = -10; int y = 2147483647; return x - y;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
try {
exec("long x = -10L; long y = 9223372036854775807L; return x - y;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
}
public void testSubtractionConst() throws Exception {
try {
exec("return -10 - 2147483647;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
try {
exec("return -10L - 9223372036854775807L;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
}
public void testMultiplication() throws Exception {
try {
exec("int x = 2147483647; int y = 2147483647; return x * y;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
try {
exec("long x = 9223372036854775807L; long y = 9223372036854775807L; return x * y;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
}
public void testMultiplicationConst() throws Exception {
try {
exec("return 2147483647 * 2147483647;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
try {
exec("return 9223372036854775807L * 9223372036854775807L;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
}
public void testDivision() throws Exception {
try {
exec("int x = -2147483647 - 1; int y = -1; return x / y;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
try {
exec("long x = -9223372036854775808L; long y = -1L; return x / y;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
}
public void testDivisionConst() throws Exception {
try {
exec("return (-2147483648) / -1;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
try {
exec("return (-9223372036854775808L) / -1L;");
fail("should have hit exception");
} catch (ArithmeticException expected) {}
}
public void testNegationOverflow() throws Exception {
try {
exec("int x = -2147483648; x = -x; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("long x = -9223372036854775808L; x = -x; return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testNegationOverflowConst() throws Exception {
try {
exec("int x = -(-2147483648); return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
exec("long x = -(-9223372036854775808L); return x;");
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
}

194
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/IntegerOverflowEnabledTests.java Normal file
View File

@ -0,0 +1,194 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import org.elasticsearch.common.settings.Settings;
/** Tests integer overflow with numeric overflow enabled */
public class IntegerOverflowEnabledTests extends ScriptTestCase {
@Override
protected Settings getSettings() {
Settings.Builder builder = Settings.builder();
builder.put(super.getSettings());
builder.put(PlanAScriptEngineService.NUMERIC_OVERFLOW, true);
return builder.build();
}
public void testAssignmentAdditionOverflow() {
// byte
assertEquals((byte)(0 + 128), exec("byte x = 0; x += 128; return x;"));
assertEquals((byte)(0 + -129), exec("byte x = 0; x += -129; return x;"));
// short
assertEquals((short)(0 + 32768), exec("short x = 0; x += 32768; return x;"));
assertEquals((short)(0 + -32769), exec("short x = 0; x += -32769; return x;"));
// char
assertEquals((char)(0 + 65536), exec("char x = 0; x += 65536; return x;"));
assertEquals((char)(0 + -65536), exec("char x = 0; x += -65536; return x;"));
// int
assertEquals(1 + 2147483647, exec("int x = 1; x += 2147483647; return x;"));
assertEquals(-2 + -2147483647, exec("int x = -2; x += -2147483647; return x;"));
// long
assertEquals(1L + 9223372036854775807L, exec("long x = 1; x += 9223372036854775807L; return x;"));
assertEquals(-2L + -9223372036854775807L, exec("long x = -2; x += -9223372036854775807L; return x;"));
}
public void testAssignmentSubtractionOverflow() {
// byte
assertEquals((byte)(0 - -128), exec("byte x = 0; x -= -128; return x;"));
assertEquals((byte)(0 - 129), exec("byte x = 0; x -= 129; return x;"));
// short
assertEquals((short)(0 - -32768), exec("short x = 0; x -= -32768; return x;"));
assertEquals((short)(0 - 32769), exec("short x = 0; x -= 32769; return x;"));
// char
assertEquals((char)(0 - -65536), exec("char x = 0; x -= -65536; return x;"));
assertEquals((char)(0 - 65536), exec("char x = 0; x -= 65536; return x;"));
// int
assertEquals(1 - -2147483647, exec("int x = 1; x -= -2147483647; return x;"));
assertEquals(-2 - 2147483647, exec("int x = -2; x -= 2147483647; return x;"));
// long
assertEquals(1L - -9223372036854775807L, exec("long x = 1; x -= -9223372036854775807L; return x;"));
assertEquals(-2L - 9223372036854775807L, exec("long x = -2; x -= 9223372036854775807L; return x;"));
}
public void testAssignmentMultiplicationOverflow() {
// byte
assertEquals((byte) (2 * 128), exec("byte x = 2; x *= 128; return x;"));
assertEquals((byte) (2 * -128), exec("byte x = 2; x *= -128; return x;"));
// char
assertEquals((char) (2 * 65536), exec("char x = 2; x *= 65536; return x;"));
assertEquals((char) (2 * -65536), exec("char x = 2; x *= -65536; return x;"));
// int
assertEquals(2 * 2147483647, exec("int x = 2; x *= 2147483647; return x;"));
assertEquals(2 * -2147483647, exec("int x = 2; x *= -2147483647; return x;"));
// long
assertEquals(2L * 9223372036854775807L, exec("long x = 2; x *= 9223372036854775807L; return x;"));
assertEquals(2L * -9223372036854775807L, exec("long x = 2; x *= -9223372036854775807L; return x;"));
}
public void testAssignmentDivisionOverflow() {
// byte
assertEquals((byte) (-128 / -1), exec("byte x = (byte) -128; x /= -1; return x;"));
// short
assertEquals((short) (-32768 / -1), exec("short x = (short) -32768; x /= -1; return x;"));
// cannot happen for char: unsigned
// int
assertEquals((-2147483647 - 1) / -1, exec("int x = -2147483647 - 1; x /= -1; return x;"));
// long
assertEquals((-9223372036854775807L - 1L) / -1L, exec("long x = -9223372036854775807L - 1L; x /=-1L; return x;"));
}
public void testIncrementOverFlow() throws Exception {
// byte
assertEquals((byte) 128, exec("byte x = 127; ++x; return x;"));
assertEquals((byte) 128, exec("byte x = 127; x++; return x;"));
assertEquals((byte) -129, exec("byte x = (byte) -128; --x; return x;"));
assertEquals((byte) -129, exec("byte x = (byte) -128; x--; return x;"));
// short
assertEquals((short) 32768, exec("short x = 32767; ++x; return x;"));
assertEquals((short) 32768, exec("short x = 32767; x++; return x;"));
assertEquals((short) -32769, exec("short x = (short) -32768; --x; return x;"));
assertEquals((short) -32769, exec("short x = (short) -32768; x--; return x;"));
// char
assertEquals((char) 65536, exec("char x = 65535; ++x; return x;"));
assertEquals((char) 65536, exec("char x = 65535; x++; return x;"));
assertEquals((char) -1, exec("char x = (char) 0; --x; return x;"));
assertEquals((char) -1, exec("char x = (char) 0; x--; return x;"));
// int
assertEquals(2147483647 + 1, exec("int x = 2147483647; ++x; return x;"));
assertEquals(2147483647 + 1, exec("int x = 2147483647; x++; return x;"));
assertEquals(-2147483648 - 1, exec("int x = (int) -2147483648L; --x; return x;"));
assertEquals(-2147483648 - 1, exec("int x = (int) -2147483648L; x--; return x;"));
// long
assertEquals(9223372036854775807L + 1L, exec("long x = 9223372036854775807L; ++x; return x;"));
assertEquals(9223372036854775807L + 1L, exec("long x = 9223372036854775807L; x++; return x;"));
assertEquals(-9223372036854775807L - 1L - 1L, exec("long x = -9223372036854775807L - 1L; --x; return x;"));
assertEquals(-9223372036854775807L - 1L - 1L, exec("long x = -9223372036854775807L - 1L; x--; return x;"));
}
public void testAddition() throws Exception {
assertEquals(2147483647 + 2147483647, exec("int x = 2147483647; int y = 2147483647; return x + y;"));
assertEquals(9223372036854775807L + 9223372036854775807L, exec("long x = 9223372036854775807L; long y = 9223372036854775807L; return x + y;"));
}
public void testAdditionConst() throws Exception {
assertEquals(2147483647 + 2147483647, exec("return 2147483647 + 2147483647;"));
assertEquals(9223372036854775807L + 9223372036854775807L, exec("return 9223372036854775807L + 9223372036854775807L;"));
}
public void testSubtraction() throws Exception {
assertEquals(-10 - 2147483647, exec("int x = -10; int y = 2147483647; return x - y;"));
assertEquals(-10L - 9223372036854775807L, exec("long x = -10L; long y = 9223372036854775807L; return x - y;"));
}
public void testSubtractionConst() throws Exception {
assertEquals(-10 - 2147483647, exec("return -10 - 2147483647;"));
assertEquals(-10L - 9223372036854775807L, exec("return -10L - 9223372036854775807L;"));
}
public void testMultiplication() throws Exception {
assertEquals(2147483647 * 2147483647, exec("int x = 2147483647; int y = 2147483647; return x * y;"));
assertEquals(9223372036854775807L * 9223372036854775807L, exec("long x = 9223372036854775807L; long y = 9223372036854775807L; return x * y;"));
}
public void testMultiplicationConst() throws Exception {
assertEquals(2147483647 * 2147483647, exec("return 2147483647 * 2147483647;"));
assertEquals(9223372036854775807L * 9223372036854775807L, exec("return 9223372036854775807L * 9223372036854775807L;"));
}
public void testDivision() throws Exception {
assertEquals((-2147483647 - 1) / -1, exec("int x = -2147483648; int y = -1; return x / y;"));
assertEquals((-9223372036854775807L - 1L) / -1L, exec("long x = -9223372036854775808L; long y = -1L; return x / y;"));
}
public void testDivisionConst() throws Exception {
assertEquals((-2147483647 - 1) / -1, exec("return (-2147483648) / -1;"));
assertEquals((-9223372036854775807L - 1L) / -1L, exec("return (-9223372036854775808L) / -1L;"));
}
public void testNegationOverflow() throws Exception {
assertEquals(-(-2147483647 - 1), exec("int x = -2147483648; x = -x; return x;"));
assertEquals(-(-9223372036854775807L - 1L), exec("long x = -9223372036854775808L; x = -x; return x;"));
}
public void testNegationOverflowConst() throws Exception {
assertEquals(-(-2147483647 - 1), exec("int x = -(-2147483648); return x;"));
assertEquals(-(-9223372036854775807L - 1L), exec("long x = -(-9223372036854775808L); return x;"));
}
}

126
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/MultiplicationTests.java Normal file
View File

@ -0,0 +1,126 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
/** Tests for multiplication operator across all types */
//TODO: NaN/Inf/overflow/...
public class MultiplicationTests extends ScriptTestCase {
// TODO: short,byte,char
public void testInt() throws Exception {
assertEquals(1*1, exec("int x = 1; int y = 1; return x*y;"));
assertEquals(2*3, exec("int x = 2; int y = 3; return x*y;"));
assertEquals(5*10, exec("int x = 5; int y = 10; return x*y;"));
assertEquals(1*1*2, exec("int x = 1; int y = 1; int z = 2; return x*y*z;"));
assertEquals((1*1)*2, exec("int x = 1; int y = 1; int z = 2; return (x*y)*z;"));
assertEquals(1*(1*2), exec("int x = 1; int y = 1; int z = 2; return x*(y*z);"));
assertEquals(10*0, exec("int x = 10; int y = 0; return x*y;"));
assertEquals(0*0, exec("int x = 0; int y = 0; return x*x;"));
}
public void testIntConst() throws Exception {
assertEquals(1*1, exec("return 1*1;"));
assertEquals(2*3, exec("return 2*3;"));
assertEquals(5*10, exec("return 5*10;"));
assertEquals(1*1*2, exec("return 1*1*2;"));
assertEquals((1*1)*2, exec("return (1*1)*2;"));
assertEquals(1*(1*2), exec("return 1*(1*2);"));
assertEquals(10*0, exec("return 10*0;"));
assertEquals(0*0, exec("return 0*0;"));
}
public void testByte() throws Exception {
assertEquals((byte)1*(byte)1, exec("byte x = 1; byte y = 1; return x*y;"));
assertEquals((byte)2*(byte)3, exec("byte x = 2; byte y = 3; return x*y;"));
assertEquals((byte)5*(byte)10, exec("byte x = 5; byte y = 10; return x*y;"));
assertEquals((byte)1*(byte)1*(byte)2, exec("byte x = 1; byte y = 1; byte z = 2; return x*y*z;"));
assertEquals(((byte)1*(byte)1)*(byte)2, exec("byte x = 1; byte y = 1; byte z = 2; return (x*y)*z;"));
assertEquals((byte)1*((byte)1*(byte)2), exec("byte x = 1; byte y = 1; byte z = 2; return x*(y*z);"));
assertEquals((byte)10*(byte)0, exec("byte x = 10; byte y = 0; return x*y;"));
assertEquals((byte)0*(byte)0, exec("byte x = 0; byte y = 0; return x*x;"));
}
public void testLong() throws Exception {
assertEquals(1L*1L, exec("long x = 1; long y = 1; return x*y;"));
assertEquals(2L*3L, exec("long x = 2; long y = 3; return x*y;"));
assertEquals(5L*10L, exec("long x = 5; long y = 10; return x*y;"));
assertEquals(1L*1L*2L, exec("long x = 1; long y = 1; int z = 2; return x*y*z;"));
assertEquals((1L*1L)*2L, exec("long x = 1; long y = 1; int z = 2; return (x*y)*z;"));
assertEquals(1L*(1L*2L), exec("long x = 1; long y = 1; int z = 2; return x*(y*z);"));
assertEquals(10L*0L, exec("long x = 10; long y = 0; return x*y;"));
assertEquals(0L*0L, exec("long x = 0; long y = 0; return x*x;"));
}
public void testLongConst() throws Exception {
assertEquals(1L*1L, exec("return 1L*1L;"));
assertEquals(2L*3L, exec("return 2L*3L;"));
assertEquals(5L*10L, exec("return 5L*10L;"));
assertEquals(1L*1L*2L, exec("return 1L*1L*2L;"));
assertEquals((1L*1L)*2L, exec("return (1L*1L)*2L;"));
assertEquals(1L*(1L*2L), exec("return 1L*(1L*2L);"));
assertEquals(10L*0L, exec("return 10L*0L;"));
assertEquals(0L*0L, exec("return 0L*0L;"));
}
public void testFloat() throws Exception {
assertEquals(1F*1F, exec("float x = 1; float y = 1; return x*y;"));
assertEquals(2F*3F, exec("float x = 2; float y = 3; return x*y;"));
assertEquals(5F*10F, exec("float x = 5; float y = 10; return x*y;"));
assertEquals(1F*1F*2F, exec("float x = 1; float y = 1; float z = 2; return x*y*z;"));
assertEquals((1F*1F)*2F, exec("float x = 1; float y = 1; float z = 2; return (x*y)*z;"));
assertEquals(1F*(1F*2F), exec("float x = 1; float y = 1; float z = 2; return x*(y*z);"));
assertEquals(10F*0F, exec("float x = 10; float y = 0; return x*y;"));
assertEquals(0F*0F, exec("float x = 0; float y = 0; return x*x;"));
}
public void testFloatConst() throws Exception {
assertEquals(1F*1F, exec("return 1F*1F;"));
assertEquals(2F*3F, exec("return 2F*3F;"));
assertEquals(5F*10F, exec("return 5F*10F;"));
assertEquals(1F*1F*2F, exec("return 1F*1F*2F;"));
assertEquals((1F*1F)*2F, exec("return (1F*1F)*2F;"));
assertEquals(1F*(1F*2F), exec("return 1F*(1F*2F);"));
assertEquals(10F*0F, exec("return 10F*0F;"));
assertEquals(0F*0F, exec("return 0F*0F;"));
}
public void testDouble() throws Exception {
assertEquals(1D*1D, exec("double x = 1; double y = 1; return x*y;"));
assertEquals(2D*3D, exec("double x = 2; double y = 3; return x*y;"));
assertEquals(5D*10D, exec("double x = 5; double y = 10; return x*y;"));
assertEquals(1D*1D*2D, exec("double x = 1; double y = 1; double z = 2; return x*y*z;"));
assertEquals((1D*1D)*2D, exec("double x = 1; double y = 1; double z = 2; return (x*y)*z;"));
assertEquals(1D*(1D*2D), exec("double x = 1; double y = 1; double z = 2; return x*(y*z);"));
assertEquals(10D*0D, exec("double x = 10; float y = 0; return x*y;"));
assertEquals(0D*0D, exec("double x = 0; float y = 0; return x*x;"));
}
public void testDoubleConst() throws Exception {
assertEquals(1.0*1.0, exec("return 1.0*1.0;"));
assertEquals(2.0*3.0, exec("return 2.0*3.0;"));
assertEquals(5.0*10.0, exec("return 5.0*10.0;"));
assertEquals(1.0*1.0*2.0, exec("return 1.0*1.0*2.0;"));
assertEquals((1.0*1.0)*2.0, exec("return (1.0*1.0)*2.0;"));
assertEquals(1.0*(1.0*2.0), exec("return 1.0*(1.0*2.0);"));
assertEquals(10.0*0.0, exec("return 10.0*0.0;"));
assertEquals(0.0*0.0, exec("return 0.0*0.0;"));
}
}

178
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/NoSemiColonTest.java Normal file
View File

@ -0,0 +1,178 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import java.util.HashMap;
import java.util.Map;
public class NoSemiColonTest extends ScriptTestCase {
public void testIfStatement() {
assertEquals(1, exec("int x = 5 if (x == 5) return 1 return 0"));
assertEquals(0, exec("int x = 4 if (x == 5) return 1 else return 0"));
assertEquals(2, exec("int x = 4 if (x == 5) return 1 else if (x == 4) return 2 else return 0"));
assertEquals(1, exec("int x = 4 if (x == 5) return 1 else if (x == 4) return 1 else return 0"));
assertEquals(3, exec(
"int x = 5\n" +
"if (x == 5) {\n" +
" int y = 2\n" +
" \n" +
" if (y == 2) {\n" +
" x = 3\n" +
" }\n" +
" \n" +
"}\n" +
"\n" +
"return x\n"));
}
public void testWhileStatement() {
assertEquals("aaaaaa", exec("String c = \"a\" int x while (x < 5) { c ..= \"a\" ++x } return c"));
Object value = exec(
" byte[][] b = new byte[5][5] \n" +
" byte x = 0, y \n" +
" \n" +
" while (x < 5) { \n" +
" y = 0 \n" +
" \n" +
" while (y < 5) { \n" +
" b[x][y] = (byte)(x*y) \n" +
" ++y \n" +
" } \n" +
" \n" +
" ++x \n" +
" } \n" +
" \n" +
" return b \n");
byte[][] b = (byte[][])value;
for (byte x = 0; x < 5; ++x) {
for (byte y = 0; y < 5; ++y) {
assertEquals(x*y, b[x][y]);
}
}
}
public void testDoWhileStatement() {
assertEquals("aaaaaa", exec("String c = \"a\" int x do { c ..= \"a\" ++x } while (x < 5) return c"));
Object value = exec(
" long[][] l = new long[5][5] \n" +
" long x = 0, y \n" +
" \n" +
" do { \n" +
" y = 0 \n" +
" \n" +
" do { \n" +
" l[(int)x][(int)y] = x*y \n" +
" ++y \n" +
" } while (y < 5) \n" +
" \n" +
" ++x \n" +
" } while (x < 5) \n" +
" \n" +
" return l \n");
long[][] l = (long[][])value;
for (long x = 0; x < 5; ++x) {
for (long y = 0; y < 5; ++y) {
assertEquals(x*y, l[(int)x][(int)y]);
}
}
}
public void testForStatement() {
assertEquals("aaaaaa", exec("String c = \"a\" for (int x = 0; x < 5; ++x) c ..= \"a\" return c"));
Object value = exec(
" int[][] i = new int[5][5] \n" +
" for (int x = 0; x < 5; ++x) { \n" +
" for (int y = 0; y < 5; ++y) { \n" +
" i[x][y] = x*y \n" +
" } \n" +
" } \n" +
" \n" +
" return i \n");
int[][] i = (int[][])value;
for (int x = 0; x < 5; ++x) {
for (int y = 0; y < 5; ++y) {
assertEquals(x*y, i[x][y]);
}
}
}
public void testDeclarationStatement() {
assertEquals((byte)2, exec("byte a = 2 return a"));
assertEquals((short)2, exec("short a = 2 return a"));
assertEquals((char)2, exec("char a = 2 return a"));
assertEquals(2, exec("int a = 2 return a"));
assertEquals(2L, exec("long a = 2 return a"));
assertEquals(2F, exec("float a = 2 return a"));
assertEquals(2.0, exec("double a = 2 return a"));
assertEquals(false, exec("boolean a = false return a"));
assertEquals("string", exec("String a = \"string\" return a"));
assertEquals(HashMap.class, exec("Map<String, Object> a = new HashMap<String, Object>() return a").getClass());
assertEquals(byte[].class, exec("byte[] a = new byte[1] return a").getClass());
assertEquals(short[].class, exec("short[] a = new short[1] return a").getClass());
assertEquals(char[].class, exec("char[] a = new char[1] return a").getClass());
assertEquals(int[].class, exec("int[] a = new int[1] return a").getClass());
assertEquals(long[].class, exec("long[] a = new long[1] return a").getClass());
assertEquals(float[].class, exec("float[] a = new float[1] return a").getClass());
assertEquals(double[].class, exec("double[] a = new double[1] return a").getClass());
assertEquals(boolean[].class, exec("boolean[] a = new boolean[1] return a").getClass());
assertEquals(String[].class, exec("String[] a = new String[1] return a").getClass());
assertEquals(Map[].class, exec("Map<String,Object>[] a = new Map<String,Object>[1] return a").getClass());
assertEquals(byte[][].class, exec("byte[][] a = new byte[1][2] return a").getClass());
assertEquals(short[][][].class, exec("short[][][] a = new short[1][2][3] return a").getClass());
assertEquals(char[][][][].class, exec("char[][][][] a = new char[1][2][3][4] return a").getClass());
assertEquals(int[][][][][].class, exec("int[][][][][] a = new int[1][2][3][4][5] return a").getClass());
assertEquals(long[][].class, exec("long[][] a = new long[1][2] return a").getClass());
assertEquals(float[][][].class, exec("float[][][] a = new float[1][2][3] return a").getClass());
assertEquals(double[][][][].class, exec("double[][][][] a = new double[1][2][3][4] return a").getClass());
assertEquals(boolean[][][][][].class, exec("boolean[][][][][] a = new boolean[1][2][3][4][5] return a").getClass());
assertEquals(String[][].class, exec("String[][] a = new String[1][2] return a").getClass());
assertEquals(Map[][][].class, exec("Map<String,Object>[][][] a = new Map<String,Object>[1][2][3] return a").getClass());
}
public void testContinueStatement() {
assertEquals(9, exec("int x = 0, y = 0 while (x < 10) { ++x if (x == 1) continue ++y } return y"));
}
public void testBreakStatement() {
assertEquals(4, exec("int x = 0, y = 0 while (x < 10) { ++x if (x == 5) break ++y } return y"));
}
public void testReturnStatement() {
assertEquals(10, exec("return 10"));
assertEquals(5, exec("int x = 5 return x"));
assertEquals(4, exec("int[] x = new int[2] x[1] = 4 return x[1]"));
assertEquals(5, ((short[])exec("short[] s = new short[3] s[1] = 5 return s"))[1]);
assertEquals(10, ((Map)exec("Map<String,Object> s = new HashMap< String,Object>() s.put(\"x\", 10) return s")).get("x"));
}
}

48
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/OrTests.java Normal file
View File

@ -0,0 +1,48 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
/** Tests for or operator across all types */
public class OrTests extends ScriptTestCase {
public void testInt() throws Exception {
assertEquals(5 | 12, exec("int x = 5; int y = 12; return x | y;"));
assertEquals(5 | -12, exec("int x = 5; int y = -12; return x | y;"));
assertEquals(7 | 15 | 3, exec("int x = 7; int y = 15; int z = 3; return x | y | z;"));
}
public void testIntConst() throws Exception {
assertEquals(5 | 12, exec("return 5 | 12;"));
assertEquals(5 | -12, exec("return 5 | -12;"));
assertEquals(7 | 15 | 3, exec("return 7 | 15 | 3;"));
}
public void testLong() throws Exception {
assertEquals(5L | 12L, exec("long x = 5; long y = 12; return x | y;"));
assertEquals(5L | -12L, exec("long x = 5; long y = -12; return x | y;"));
assertEquals(7L | 15L | 3L, exec("long x = 7; long y = 15; long z = 3; return x | y | z;"));
}
public void testLongConst() throws Exception {
assertEquals(5L | 12L, exec("return 5L | 12L;"));
assertEquals(5L | -12L, exec("return 5L | -12L;"));
assertEquals(7L | 15L | 3L, exec("return 7L | 15L | 3L;"));
}
}

49
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/PlanARestIT.java Normal file
View File

@ -0,0 +1,49 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import com.carrotsearch.randomizedtesting.annotations.Name;
import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
import org.elasticsearch.plugins.Plugin;
import org.elasticsearch.test.rest.ESRestTestCase;
import org.elasticsearch.test.rest.RestTestCandidate;
import org.elasticsearch.test.rest.parser.RestTestParseException;
import java.io.IOException;
import java.util.Collection;
/** Runs yaml rest tests */
public class PlanARestIT extends ESRestTestCase {
@Override
protected Collection<Class<? extends Plugin>> nodePlugins() {
return pluginList(PlanAPlugin.class);
}
public PlanARestIT(@Name("yaml") RestTestCandidate testCandidate) {
super(testCandidate);
}
@ParametersFactory
public static Iterable<Object[]> parameters() throws IOException, RestTestParseException {
return ESRestTestCase.createParameters(0, 1);
}
}

147
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/RemainderTests.java Normal file
View File

@ -0,0 +1,147 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
/** Tests for division operator across all types */
//TODO: NaN/Inf/overflow/...
public class RemainderTests extends ScriptTestCase {
// TODO: byte,short,char
public void testInt() throws Exception {
assertEquals(1%1, exec("int x = 1; int y = 1; return x%y;"));
assertEquals(2%3, exec("int x = 2; int y = 3; return x%y;"));
assertEquals(5%10, exec("int x = 5; int y = 10; return x%y;"));
assertEquals(10%1%2, exec("int x = 10; int y = 1; int z = 2; return x%y%z;"));
assertEquals((10%1)%2, exec("int x = 10; int y = 1; int z = 2; return (x%y)%z;"));
assertEquals(10%(4%3), exec("int x = 10; int y = 4; int z = 3; return x%(y%z);"));
assertEquals(10%1, exec("int x = 10; int y = 1; return x%y;"));
assertEquals(0%1, exec("int x = 0; int y = 1; return x%y;"));
}
public void testIntConst() throws Exception {
assertEquals(1%1, exec("return 1%1;"));
assertEquals(2%3, exec("return 2%3;"));
assertEquals(5%10, exec("return 5%10;"));
assertEquals(10%1%2, exec("return 10%1%2;"));
assertEquals((10%1)%2, exec("return (10%1)%2;"));
assertEquals(10%(4%3), exec("return 10%(4%3);"));
assertEquals(10%1, exec("return 10%1;"));
assertEquals(0%1, exec("return 0%1;"));
}
public void testLong() throws Exception {
assertEquals(1L%1L, exec("long x = 1; long y = 1; return x%y;"));
assertEquals(2L%3L, exec("long x = 2; long y = 3; return x%y;"));
assertEquals(5L%10L, exec("long x = 5; long y = 10; return x%y;"));
assertEquals(10L%1L%2L, exec("long x = 10; long y = 1; long z = 2; return x%y%z;"));
assertEquals((10L%1L)%2L, exec("long x = 10; long y = 1; long z = 2; return (x%y)%z;"));
assertEquals(10L%(4L%3L), exec("long x = 10; long y = 4; long z = 3; return x%(y%z);"));
assertEquals(10L%1L, exec("long x = 10; long y = 1; return x%y;"));
assertEquals(0L%1L, exec("long x = 0; long y = 1; return x%y;"));
}
public void testLongConst() throws Exception {
assertEquals(1L%1L, exec("return 1L%1L;"));
assertEquals(2L%3L, exec("return 2L%3L;"));
assertEquals(5L%10L, exec("return 5L%10L;"));
assertEquals(10L%1L%2L, exec("return 10L%1L%2L;"));
assertEquals((10L%1L)%2L, exec("return (10L%1L)%2L;"));
assertEquals(10L%(4L%3L), exec("return 10L%(4L%3L);"));
assertEquals(10L%1L, exec("return 10L%1L;"));
assertEquals(0L%1L, exec("return 0L%1L;"));
}
public void testFloat() throws Exception {
assertEquals(1F%1F, exec("float x = 1; float y = 1; return x%y;"));
assertEquals(2F%3F, exec("float x = 2; float y = 3; return x%y;"));
assertEquals(5F%10F, exec("float x = 5; float y = 10; return x%y;"));
assertEquals(10F%1F%2F, exec("float x = 10; float y = 1; float z = 2; return x%y%z;"));
assertEquals((10F%1F)%2F, exec("float x = 10; float y = 1; float z = 2; return (x%y)%z;"));
assertEquals(10F%(4F%3F), exec("float x = 10; float y = 4; float z = 3; return x%(y%z);"));
assertEquals(10F%1F, exec("float x = 10; float y = 1; return x%y;"));
assertEquals(0F%1F, exec("float x = 0; float y = 1; return x%y;"));
}
public void testFloatConst() throws Exception {
assertEquals(1F%1F, exec("return 1F%1F;"));
assertEquals(2F%3F, exec("return 2F%3F;"));
assertEquals(5F%10F, exec("return 5F%10F;"));
assertEquals(10F%1F%2F, exec("return 10F%1F%2F;"));
assertEquals((10F%1F)%2F, exec("return (10F%1F)%2F;"));
assertEquals(10F%(4F%3F), exec("return 10F%(4F%3F);"));
assertEquals(10F%1F, exec("return 10F%1F;"));
assertEquals(0F%1F, exec("return 0F%1F;"));
}
public void testDouble() throws Exception {
assertEquals(1.0%1.0, exec("double x = 1; double y = 1; return x%y;"));
assertEquals(2.0%3.0, exec("double x = 2; double y = 3; return x%y;"));
assertEquals(5.0%10.0, exec("double x = 5; double y = 10; return x%y;"));
assertEquals(10.0%1.0%2.0, exec("double x = 10; double y = 1; double z = 2; return x%y%z;"));
assertEquals((10.0%1.0)%2.0, exec("double x = 10; double y = 1; double z = 2; return (x%y)%z;"));
assertEquals(10.0%(4.0%3.0), exec("double x = 10; double y = 4; double z = 3; return x%(y%z);"));
assertEquals(10.0%1.0, exec("double x = 10; double y = 1; return x%y;"));
assertEquals(0.0%1.0, exec("double x = 0; double y = 1; return x%y;"));
}
public void testDoubleConst() throws Exception {
assertEquals(1.0%1.0, exec("return 1.0%1.0;"));
assertEquals(2.0%3.0, exec("return 2.0%3.0;"));
assertEquals(5.0%10.0, exec("return 5.0%10.0;"));
assertEquals(10.0%1.0%2.0, exec("return 10.0%1.0%2.0;"));
assertEquals((10.0%1.0)%2.0, exec("return (10.0%1.0)%2.0;"));
assertEquals(10.0%(4.0%3.0), exec("return 10.0%(4.0%3.0);"));
assertEquals(10.0%1.0, exec("return 10.0%1.0;"));
assertEquals(0.0%1.0, exec("return 0.0%1.0;"));
}
public void testDivideByZero() throws Exception {
try {
exec("int x = 1; int y = 0; return x % y;");
fail("should have hit exception");
} catch (ArithmeticException expected) {
// divide by zero
}
try {
exec("long x = 1L; long y = 0L; return x % y;");
fail("should have hit exception");
} catch (ArithmeticException expected) {
// divide by zero
}
}
public void testDivideByZeroConst() throws Exception {
try {
exec("return 1%0;");
fail("should have hit exception");
} catch (ArithmeticException expected) {
// divide by zero
}
try {
exec("return 1L%0L;");
fail("should have hit exception");
} catch (ArithmeticException expected) {
// divide by zero
}
}
}

109
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/ScriptEngineTests.java Normal file
View File

@ -0,0 +1,109 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import org.elasticsearch.script.CompiledScript;
import org.elasticsearch.script.ExecutableScript;
import org.elasticsearch.script.ScriptService;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public class ScriptEngineTests extends ScriptTestCase {
public void testSimpleEquation() {
final Object value = exec("return 1 + 2;");
assertEquals(3, ((Number)value).intValue());
}
public void testMapAccess() {
Map<String, Object> vars = new HashMap<>();
Map<String, Object> obj2 = new HashMap<>();
obj2.put("prop2", "value2");
Map<String, Object> obj1 = new HashMap<>();
obj1.put("prop1", "value1");
obj1.put("obj2", obj2);
obj1.put("l", Arrays.asList("2", "1"));
vars.put("obj1", obj1);
Object value = exec("return input.get(\"obj1\");", vars);
obj1 = (Map<String, Object>)value;
assertEquals("value1", obj1.get("prop1"));
assertEquals("value2", ((Map<String, Object>) obj1.get("obj2")).get("prop2"));
value = exec("return ((List)((Map<String, Object>)input.get(\"obj1\")).get(\"l\")).get(0);", vars);
assertEquals("2", value);
}
public void testAccessListInScript() {
Map<String, Object> vars = new HashMap<>();
Map<String, Object> obj2 = new HashMap<>();
obj2.put("prop2", "value2");
Map<String, Object> obj1 = new HashMap<>();
obj1.put("prop1", "value1");
obj1.put("obj2", obj2);
vars.put("l", Arrays.asList("1", "2", "3", obj1));
assertEquals(4, exec("return ((List)input.get(\"l\")).size();", vars));
assertEquals("1", exec("return ((List)input.get(\"l\")).get(0);", vars));
Object value = exec("return ((List)input.get(\"l\")).get(3);", vars);
obj1 = (Map<String, Object>)value;
assertEquals("value1", obj1.get("prop1"));
assertEquals("value2", ((Map<String, Object>)obj1.get("obj2")).get("prop2"));
assertEquals("value1", exec("return ((Map<String, Object>)((List)input.get(\"l\")).get(3)).get(\"prop1\");", vars));
}
public void testChangingVarsCrossExecution1() {
Map<String, Object> vars = new HashMap<>();
Map<String, Object> ctx = new HashMap<>();
vars.put("ctx", ctx);
Object compiledScript = scriptEngine.compile("return ((Map<String, Object>)input.get(\"ctx\")).get(\"value\");");
ExecutableScript script = scriptEngine.executable(new CompiledScript(ScriptService.ScriptType.INLINE,
"testChangingVarsCrossExecution1", "plan-a", compiledScript), vars);
ctx.put("value", 1);
Object o = script.run();
assertEquals(1, ((Number) o).intValue());
ctx.put("value", 2);
o = script.run();
assertEquals(2, ((Number) o).intValue());
}
public void testChangingVarsCrossExecution2() {
Map<String, Object> vars = new HashMap<>();
Object compiledScript = scriptEngine.compile("return input.get(\"value\");");
ExecutableScript script = scriptEngine.executable(new CompiledScript(ScriptService.ScriptType.INLINE,
"testChangingVarsCrossExecution2", "plan-a", compiledScript), vars);
script.setNextVar("value", 1);
Object value = script.run();
assertEquals(1, ((Number)value).intValue());
script.setNextVar("value", 2);
value = script.run();
assertEquals(2, ((Number)value).intValue());
}
}

61
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/ScriptTestCase.java Normal file
View File

@ -0,0 +1,61 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.script.CompiledScript;
import org.elasticsearch.script.ScriptService;
import org.elasticsearch.test.ESTestCase;
import org.junit.Before;
import java.util.Map;
/**
* Base test case for scripting unit tests.
* <p>
* Typically just asserts the output of {@code exec()}
*/
public abstract class ScriptTestCase extends ESTestCase {
protected PlanAScriptEngineService scriptEngine;
/** Override to provide different compiler settings */
protected Settings getSettings() {
Settings.Builder builder = Settings.builder();
builder.put(PlanAScriptEngineService.NUMERIC_OVERFLOW, random().nextBoolean());
return builder.build();
}
@Before
public void setup() {
scriptEngine = new PlanAScriptEngineService(getSettings());
}
/** Compiles and returns the result of {@code script} */
public Object exec(String script) {
return exec(script, null);
}
/** Compiles and returns the result of {@code script} with access to {@code vars} */
public Object exec(String script, Map<String, Object> vars) {
Object object = scriptEngine.compile(script);
CompiledScript compiled = new CompiledScript(ScriptService.ScriptType.INLINE, getTestName(), "plan-a", object);
return scriptEngine.executable(compiled, vars).run();
}
}

75
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/StringTests.java Normal file
View File

@ -0,0 +1,75 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
public class StringTests extends ScriptTestCase {
public void testAppend() {
// boolean
assertEquals("cat" + true, exec("String s = \"cat\"; return s + true;"));
// byte
assertEquals("cat" + (byte)3, exec("String s = \"cat\"; return s + (byte)3;"));
// short
assertEquals("cat" + (short)3, exec("String s = \"cat\"; return s + (short)3;"));
// char
assertEquals("cat" + 't', exec("String s = \"cat\"; return s + 't';"));
assertEquals("cat" + (char)40, exec("String s = \"cat\"; return s + (char)40;"));
// int
assertEquals("cat" + 2, exec("String s = \"cat\"; return s + 2;"));
// long
assertEquals("cat" + 2L, exec("String s = \"cat\"; return s + 2L;"));
// float
assertEquals("cat" + 2F, exec("String s = \"cat\"; return s + 2F;"));
// double
assertEquals("cat" + 2.0, exec("String s = \"cat\"; return s + 2.0;"));
// String
assertEquals("cat" + "cat", exec("String s = \"cat\"; return s + s;"));
}
public void testStringAPI() {
assertEquals("", exec("return new String();"));
assertEquals('x', exec("String s = \"x\"; return s.charAt(0);"));
assertEquals(120, exec("String s = \"x\"; return s.codePointAt(0);"));
assertEquals(0, exec("String s = \"x\"; return s.compareTo(\"x\");"));
assertEquals("xx", exec("String s = \"x\"; return s.concat(\"x\");"));
assertEquals(true, exec("String s = \"xy\"; return s.endsWith(\"y\");"));
assertEquals(2, exec("String t = \"abcde\"; return t.indexOf(\"cd\", 1);"));
assertEquals(false, exec("String t = \"abcde\"; return t.isEmpty();"));
assertEquals(5, exec("String t = \"abcde\"; return t.length();"));
assertEquals("cdcde", exec("String t = \"abcde\"; return t.replace(\"ab\", \"cd\");"));
assertEquals(false, exec("String s = \"xy\"; return s.startsWith(\"y\");"));
assertEquals("e", exec("String t = \"abcde\"; return t.substring(4, 5);"));
assertEquals(97, ((char[])exec("String s = \"a\"; return s.toCharArray();"))[0]);
assertEquals("a", exec("String s = \" a \"; return s.trim();"));
assertEquals('x', exec("return \"x\".charAt(0);"));
assertEquals(120, exec("return \"x\".codePointAt(0);"));
assertEquals(0, exec("return \"x\".compareTo(\"x\");"));
assertEquals("xx", exec("return \"x\".concat(\"x\");"));
assertEquals(true, exec("return \"xy\".endsWith(\"y\");"));
assertEquals(2, exec("return \"abcde\".indexOf(\"cd\", 1);"));
assertEquals(false, exec("return \"abcde\".isEmpty();"));
assertEquals(5, exec("return \"abcde\".length();"));
assertEquals("cdcde", exec("return \"abcde\".replace(\"ab\", \"cd\");"));
assertEquals(false, exec("return \"xy\".startsWith(\"y\");"));
assertEquals("e", exec("return \"abcde\".substring(4, 5);"));
assertEquals(97, ((char[])exec("return \"a\".toCharArray();"))[0]);
assertEquals("a", exec("return \" a \".trim();"));
}
}

179
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/SubtractionTests.java Normal file
View File

@ -0,0 +1,179 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
/** Tests for subtraction operator across all types */
//TODO: NaN/Inf/overflow/...
public class SubtractionTests extends ScriptTestCase {
public void testInt() throws Exception {
assertEquals(1-1, exec("int x = 1; int y = 1; return x-y;"));
assertEquals(2-3, exec("int x = 2; int y = 3; return x-y;"));
assertEquals(5-10, exec("int x = 5; int y = 10; return x-y;"));
assertEquals(1-1-2, exec("int x = 1; int y = 1; int z = 2; return x-y-z;"));
assertEquals((1-1)-2, exec("int x = 1; int y = 1; int z = 2; return (x-y)-z;"));
assertEquals(1-(1-2), exec("int x = 1; int y = 1; int z = 2; return x-(y-z);"));
assertEquals(10-0, exec("int x = 10; int y = 0; return x-y;"));
assertEquals(0-0, exec("int x = 0; int y = 0; return x-x;"));
}
public void testIntConst() throws Exception {
assertEquals(1-1, exec("return 1-1;"));
assertEquals(2-3, exec("return 2-3;"));
assertEquals(5-10, exec("return 5-10;"));
assertEquals(1-1-2, exec("return 1-1-2;"));
assertEquals((1-1)-2, exec("return (1-1)-2;"));
assertEquals(1-(1-2), exec("return 1-(1-2);"));
assertEquals(10-0, exec("return 10-0;"));
assertEquals(0-0, exec("return 0-0;"));
}
public void testByte() throws Exception {
assertEquals((byte)1-(byte)1, exec("byte x = 1; byte y = 1; return x-y;"));
assertEquals((byte)2-(byte)3, exec("byte x = 2; byte y = 3; return x-y;"));
assertEquals((byte)5-(byte)10, exec("byte x = 5; byte y = 10; return x-y;"));
assertEquals((byte)1-(byte)1-(byte)2, exec("byte x = 1; byte y = 1; byte z = 2; return x-y-z;"));
assertEquals(((byte)1-(byte)1)-(byte)2, exec("byte x = 1; byte y = 1; byte z = 2; return (x-y)-z;"));
assertEquals((byte)1-((byte)1-(byte)2), exec("byte x = 1; byte y = 1; byte z = 2; return x-(y-z);"));
assertEquals((byte)10-(byte)1, exec("byte x = 10; byte y = 1; return x-y;"));
assertEquals((byte)0-(byte)0, exec("byte x = 0; byte y = 0; return x-y;"));
}
public void testByteConst() throws Exception {
assertEquals((byte)1-(byte)1, exec("return (byte)1-(byte)1;"));
assertEquals((byte)2-(byte)3, exec("return (byte)2-(byte)3;"));
assertEquals((byte)5-(byte)10, exec("return (byte)5-(byte)10;"));
assertEquals((byte)1-(byte)1-(byte)2, exec("return (byte)1-(byte)1-(byte)2;"));
assertEquals(((byte)1-(byte)1)-(byte)2, exec("return ((byte)1-(byte)1)-(byte)2;"));
assertEquals((byte)1-((byte)1-(byte)2), exec("return (byte)1-((byte)1-(byte)2);"));
assertEquals((byte)10-(byte)1, exec("return (byte)10-(byte)1;"));
assertEquals((byte)0-(byte)0, exec("return (byte)0-(byte)0;"));
}
public void testChar() throws Exception {
assertEquals((char)1-(char)1, exec("char x = 1; char y = 1; return x-y;"));
assertEquals((char)2-(char)3, exec("char x = 2; char y = 3; return x-y;"));
assertEquals((char)5-(char)10, exec("char x = 5; char y = 10; return x-y;"));
assertEquals((char)1-(char)1-(char)2, exec("char x = 1; char y = 1; char z = 2; return x-y-z;"));
assertEquals(((char)1-(char)1)-(char)2, exec("char x = 1; char y = 1; char z = 2; return (x-y)-z;"));
assertEquals((char)1-((char)1-(char)2), exec("char x = 1; char y = 1; char z = 2; return x-(y-z);"));
assertEquals((char)10-(char)1, exec("char x = 10; char y = 1; return x-y;"));
assertEquals((char)0-(char)0, exec("char x = 0; char y = 0; return x-y;"));
}
public void testCharConst() throws Exception {
assertEquals((char)1-(char)1, exec("return (char)1-(char)1;"));
assertEquals((char)2-(char)3, exec("return (char)2-(char)3;"));
assertEquals((char)5-(char)10, exec("return (char)5-(char)10;"));
assertEquals((char)1-(char)1-(char)2, exec("return (char)1-(char)1-(char)2;"));
assertEquals(((char)1-(char)1)-(char)2, exec("return ((char)1-(char)1)-(char)2;"));
assertEquals((char)1-((char)1-(char)2), exec("return (char)1-((char)1-(char)2);"));
assertEquals((char)10-(char)1, exec("return (char)10-(char)1;"));
assertEquals((char)0-(char)0, exec("return (char)0-(char)0;"));
}
public void testShort() throws Exception {
assertEquals((short)1-(short)1, exec("short x = 1; short y = 1; return x-y;"));
assertEquals((short)2-(short)3, exec("short x = 2; short y = 3; return x-y;"));
assertEquals((short)5-(short)10, exec("short x = 5; short y = 10; return x-y;"));
assertEquals((short)1-(short)1-(short)2, exec("short x = 1; short y = 1; short z = 2; return x-y-z;"));
assertEquals(((short)1-(short)1)-(short)2, exec("short x = 1; short y = 1; short z = 2; return (x-y)-z;"));
assertEquals((short)1-((short)1-(short)2), exec("short x = 1; short y = 1; short z = 2; return x-(y-z);"));
assertEquals((short)10-(short)1, exec("short x = 10; short y = 1; return x-y;"));
assertEquals((short)0-(short)0, exec("short x = 0; short y = 0; return x-y;"));
}
public void testShortConst() throws Exception {
assertEquals((short)1-(short)1, exec("return (short)1-(short)1;"));
assertEquals((short)2-(short)3, exec("return (short)2-(short)3;"));
assertEquals((short)5-(short)10, exec("return (short)5-(short)10;"));
assertEquals((short)1-(short)1-(short)2, exec("return (short)1-(short)1-(short)2;"));
assertEquals(((short)1-(short)1)-(short)2, exec("return ((short)1-(short)1)-(short)2;"));
assertEquals((short)1-((short)1-(short)2), exec("return (short)1-((short)1-(short)2);"));
assertEquals((short)10-(short)1, exec("return (short)10-(short)1;"));
assertEquals((short)0-(short)0, exec("return (short)0-(short)0;"));
}
public void testLong() throws Exception {
assertEquals(1L-1L, exec("long x = 1; long y = 1; return x-y;"));
assertEquals(2L-3L, exec("long x = 2; long y = 3; return x-y;"));
assertEquals(5L-10L, exec("long x = 5; long y = 10; return x-y;"));
assertEquals(1L-1L-2L, exec("long x = 1; long y = 1; int z = 2; return x-y-z;"));
assertEquals((1L-1L)-2L, exec("long x = 1; long y = 1; int z = 2; return (x-y)-z;"));
assertEquals(1L-(1L-2L), exec("long x = 1; long y = 1; int z = 2; return x-(y-z);"));
assertEquals(10L-0L, exec("long x = 10; long y = 0; return x-y;"));
assertEquals(0L-0L, exec("long x = 0; long y = 0; return x-x;"));
}
public void testLongConst() throws Exception {
assertEquals(1L-1L, exec("return 1L-1L;"));
assertEquals(2L-3L, exec("return 2L-3L;"));
assertEquals(5L-10L, exec("return 5L-10L;"));
assertEquals(1L-1L-2L, exec("return 1L-1L-2L;"));
assertEquals((1L-1L)-2L, exec("return (1L-1L)-2L;"));
assertEquals(1L-(1L-2L), exec("return 1L-(1L-2L);"));
assertEquals(10L-0L, exec("return 10L-0L;"));
assertEquals(0L-0L, exec("return 0L-0L;"));
}
public void testFloat() throws Exception {
assertEquals(1F-1F, exec("float x = 1; float y = 1; return x-y;"));
assertEquals(2F-3F, exec("float x = 2; float y = 3; return x-y;"));
assertEquals(5F-10F, exec("float x = 5; float y = 10; return x-y;"));
assertEquals(1F-1F-2F, exec("float x = 1; float y = 1; float z = 2; return x-y-z;"));
assertEquals((1F-1F)-2F, exec("float x = 1; float y = 1; float z = 2; return (x-y)-z;"));
assertEquals(1F-(1F-2F), exec("float x = 1; float y = 1; float z = 2; return x-(y-z);"));
assertEquals(10F-0F, exec("float x = 10; float y = 0; return x-y;"));
assertEquals(0F-0F, exec("float x = 0; float y = 0; return x-x;"));
}
public void testFloatConst() throws Exception {
assertEquals(1F-1F, exec("return 1F-1F;"));
assertEquals(2F-3F, exec("return 2F-3F;"));
assertEquals(5F-10F, exec("return 5F-10F;"));
assertEquals(1F-1F-2F, exec("return 1F-1F-2F;"));
assertEquals((1F-1F)-2F, exec("return (1F-1F)-2F;"));
assertEquals(1F-(1F-2F), exec("return 1F-(1F-2F);"));
assertEquals(10F-0F, exec("return 10F-0F;"));
assertEquals(0F-0F, exec("return 0F-0F;"));
}
public void testDouble() throws Exception {
assertEquals(1D-1D, exec("double x = 1; double y = 1; return x-y;"));
assertEquals(2D-3D, exec("double x = 2; double y = 3; return x-y;"));
assertEquals(5D-10D, exec("double x = 5; double y = 10; return x-y;"));
assertEquals(1D-1D-2D, exec("double x = 1; double y = 1; double z = 2; return x-y-z;"));
assertEquals((1D-1D)-2D, exec("double x = 1; double y = 1; double z = 2; return (x-y)-z;"));
assertEquals(1D-(1D-2D), exec("double x = 1; double y = 1; double z = 2; return x-(y-z);"));
assertEquals(10D-0D, exec("double x = 10; float y = 0; return x-y;"));
assertEquals(0D-0D, exec("double x = 0; float y = 0; return x-x;"));
}
public void testyDoubleConst() throws Exception {
assertEquals(1.0-1.0, exec("return 1.0-1.0;"));
assertEquals(2.0-3.0, exec("return 2.0-3.0;"));
assertEquals(5.0-10.0, exec("return 5.0-10.0;"));
assertEquals(1.0-1.0-2.0, exec("return 1.0-1.0-2.0;"));
assertEquals((1.0-1.0)-2.0, exec("return (1.0-1.0)-2.0;"));
assertEquals(1.0-(1.0-2.0), exec("return 1.0-(1.0-2.0);"));
assertEquals(10.0-0.0, exec("return 10.0-0.0;"));
assertEquals(0.0-0.0, exec("return 0.0-0.0;"));
}
}

42
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/UnaryTests.java Normal file
View File

@ -0,0 +1,42 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
/** Tests for unary operators across different types */
public class UnaryTests extends ScriptTestCase {
/** basic tests */
public void testBasics() {
assertEquals(false, exec("return !true;"));
assertEquals(true, exec("boolean x = false; return !x;"));
assertEquals(-2, exec("return ~1;"));
assertEquals(-2, exec("byte x = 1; return ~x;"));
assertEquals(1, exec("return +1;"));
assertEquals(1.0, exec("double x = 1; return +x;"));
assertEquals(-1, exec("return -1;"));
assertEquals(-2, exec("short x = 2; return -x;"));
}
public void testNegationInt() throws Exception {
assertEquals(-1, exec("return -1;"));
assertEquals(1, exec("return -(-1);"));
assertEquals(0, exec("return -0;"));
}
}

250
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/UtilityTests.java Normal file
View File

@ -0,0 +1,250 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
import org.elasticsearch.test.ESTestCase;
/**
* Tests utility methods (typically built-ins)
*/
public class UtilityTests extends ESTestCase {
public void testDivideWithoutOverflowInt() {
assertEquals(5 / 2, Utility.divideWithoutOverflow(5, 2));
try {
Utility.divideWithoutOverflow(Integer.MIN_VALUE, -1);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
Utility.divideWithoutOverflow(5, 0);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testDivideWithoutOverflowLong() {
assertEquals(5L / 2L, Utility.divideWithoutOverflow(5L, 2L));
try {
Utility.divideWithoutOverflow(Long.MIN_VALUE, -1L);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
Utility.divideWithoutOverflow(5L, 0L);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testToByteExact() {
for (int b = Byte.MIN_VALUE; b < Byte.MAX_VALUE; b++) {
assertEquals((byte)b, Utility.toByteExact(b));
}
try {
Utility.toByteExact(Byte.MIN_VALUE - 1);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
Utility.toByteExact(Byte.MAX_VALUE + 1);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testToShortExact() {
for (int s = Short.MIN_VALUE; s < Short.MAX_VALUE; s++) {
assertEquals((short)s, Utility.toShortExact(s));
}
try {
Utility.toShortExact(Short.MIN_VALUE - 1);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
Utility.toShortExact(Short.MAX_VALUE + 1);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testToCharExact() {
for (int c = Character.MIN_VALUE; c < Character.MAX_VALUE; c++) {
assertEquals((char)c, Utility.toCharExact(c));
}
try {
Utility.toCharExact(Character.MIN_VALUE - 1);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
Utility.toCharExact(Character.MAX_VALUE + 1);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testAddWithoutOverflowFloat() {
assertEquals(10F, Utility.addWithoutOverflow(5F, 5F), 0F);
assertTrue(Float.isNaN(Utility.addWithoutOverflow(5F, Float.NaN)));
assertTrue(Float.isNaN(Utility.addWithoutOverflow(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY)));
try {
Utility.addWithoutOverflow(Float.MAX_VALUE, Float.MAX_VALUE);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
Utility.addWithoutOverflow(-Float.MAX_VALUE, -Float.MAX_VALUE);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testAddWithoutOverflowDouble() {
assertEquals(10D, Utility.addWithoutOverflow(5D, 5D), 0D);
assertTrue(Double.isNaN(Utility.addWithoutOverflow(5D, Double.NaN)));
assertTrue(Double.isNaN(Utility.addWithoutOverflow(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY)));
try {
Utility.addWithoutOverflow(Double.MAX_VALUE, Double.MAX_VALUE);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
Utility.addWithoutOverflow(-Double.MAX_VALUE, -Double.MAX_VALUE);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testSubtractWithoutOverflowFloat() {
assertEquals(5F, Utility.subtractWithoutOverflow(10F, 5F), 0F);
assertTrue(Float.isNaN(Utility.subtractWithoutOverflow(5F, Float.NaN)));
assertTrue(Float.isNaN(Utility.subtractWithoutOverflow(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY)));
try {
Utility.subtractWithoutOverflow(Float.MAX_VALUE, -Float.MAX_VALUE);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
Utility.subtractWithoutOverflow(-Float.MAX_VALUE, Float.MAX_VALUE);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testSubtractWithoutOverflowDouble() {
assertEquals(5D, Utility.subtractWithoutOverflow(10D, 5D), 0D);
assertTrue(Double.isNaN(Utility.subtractWithoutOverflow(5D, Double.NaN)));
assertTrue(Double.isNaN(Utility.subtractWithoutOverflow(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY)));
try {
Utility.subtractWithoutOverflow(Double.MAX_VALUE, -Double.MAX_VALUE);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
Utility.subtractWithoutOverflow(-Double.MAX_VALUE, Double.MAX_VALUE);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testMultiplyWithoutOverflowFloat() {
assertEquals(25F, Utility.multiplyWithoutOverflow(5F, 5F), 0F);
assertTrue(Float.isNaN(Utility.multiplyWithoutOverflow(5F, Float.NaN)));
assertEquals(Float.POSITIVE_INFINITY, Utility.multiplyWithoutOverflow(5F, Float.POSITIVE_INFINITY), 0F);
try {
Utility.multiplyWithoutOverflow(Float.MAX_VALUE, Float.MAX_VALUE);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testMultiplyWithoutOverflowDouble() {
assertEquals(25D, Utility.multiplyWithoutOverflow(5D, 5D), 0D);
assertTrue(Double.isNaN(Utility.multiplyWithoutOverflow(5D, Double.NaN)));
assertEquals(Double.POSITIVE_INFINITY, Utility.multiplyWithoutOverflow(5D, Double.POSITIVE_INFINITY), 0D);
try {
Utility.multiplyWithoutOverflow(Double.MAX_VALUE, Double.MAX_VALUE);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testDivideWithoutOverflowFloat() {
assertEquals(5F, Utility.divideWithoutOverflow(25F, 5F), 0F);
assertTrue(Float.isNaN(Utility.divideWithoutOverflow(5F, Float.NaN)));
assertEquals(Float.POSITIVE_INFINITY, Utility.divideWithoutOverflow(Float.POSITIVE_INFINITY, 5F), 0F);
try {
Utility.divideWithoutOverflow(Float.MAX_VALUE, Float.MIN_VALUE);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
Utility.divideWithoutOverflow(0F, 0F);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
Utility.divideWithoutOverflow(5F, 0F);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testDivideWithoutOverflowDouble() {
assertEquals(5D, Utility.divideWithoutOverflow(25D, 5D), 0D);
assertTrue(Double.isNaN(Utility.divideWithoutOverflow(5D, Double.NaN)));
assertEquals(Double.POSITIVE_INFINITY, Utility.divideWithoutOverflow(Double.POSITIVE_INFINITY, 5D), 0D);
try {
Utility.divideWithoutOverflow(Double.MAX_VALUE, Double.MIN_VALUE);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
Utility.divideWithoutOverflow(0D, 0D);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
try {
Utility.divideWithoutOverflow(5D, 0D);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testRemainderWithoutOverflowFloat() {
assertEquals(1F, Utility.remainderWithoutOverflow(25F, 4F), 0F);
try {
Utility.remainderWithoutOverflow(5F, 0F);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
public void testRemainderWithoutOverflowDouble() {
assertEquals(1D, Utility.remainderWithoutOverflow(25D, 4D), 0D);
try {
Utility.remainderWithoutOverflow(5D, 0D);
fail("did not get expected exception");
} catch (ArithmeticException expected) {}
}
}

41
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/WhenThingsGoWrongTests.java Normal file
View File

@ -0,0 +1,41 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
public class WhenThingsGoWrongTests extends ScriptTestCase {
public void testNullPointer() {
try {
exec("int x = (int) ((Map) input).get(\"missing\"); return x;");
fail("should have hit npe");
} catch (NullPointerException expected) {}
}
public void testInvalidShift() {
try {
exec("float x = 15F; x <<= 2; return x;");
fail("should have hit cce");
} catch (ClassCastException expected) {}
try {
exec("double x = 15F; x <<= 2; return x;");
fail("should have hit cce");
} catch (ClassCastException expected) {}
}
}

62
plugins/lang-plan-a/src/test/java/org/elasticsearch/plan/a/XorTests.java Normal file
View File

@ -0,0 +1,62 @@
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.plan.a;
/** Tests for xor operator across all types */
public class XorTests extends ScriptTestCase {
public void testInt() throws Exception {
assertEquals(5 ^ 12, exec("int x = 5; int y = 12; return x ^ y;"));
assertEquals(5 ^ -12, exec("int x = 5; int y = -12; return x ^ y;"));
assertEquals(7 ^ 15 ^ 3, exec("int x = 7; int y = 15; int z = 3; return x ^ y ^ z;"));
}
public void testIntConst() throws Exception {
assertEquals(5 ^ 12, exec("return 5 ^ 12;"));
assertEquals(5 ^ -12, exec("return 5 ^ -12;"));
assertEquals(7 ^ 15 ^ 3, exec("return 7 ^ 15 ^ 3;"));
}
public void testLong() throws Exception {
assertEquals(5L ^ 12L, exec("long x = 5; long y = 12; return x ^ y;"));
assertEquals(5L ^ -12L, exec("long x = 5; long y = -12; return x ^ y;"));
assertEquals(7L ^ 15L ^ 3L, exec("long x = 7; long y = 15; long z = 3; return x ^ y ^ z;"));
}
public void testLongConst() throws Exception {
assertEquals(5L ^ 12L, exec("return 5L ^ 12L;"));
assertEquals(5L ^ -12L, exec("return 5L ^ -12L;"));
assertEquals(7L ^ 15L ^ 3L, exec("return 7L ^ 15L ^ 3L;"));
}
public void testBool() throws Exception {
assertEquals(false, exec("boolean x = true; boolean y = true; return x ^ y;"));
assertEquals(true, exec("boolean x = true; boolean y = false; return x ^ y;"));
assertEquals(true, exec("boolean x = false; boolean y = true; return x ^ y;"));
assertEquals(false, exec("boolean x = false; boolean y = false; return x ^ y;"));
}
public void testBoolConst() throws Exception {
assertEquals(false, exec("return true ^ true;"));
assertEquals(true, exec("return true ^ false;"));
assertEquals(true, exec("return false ^ true;"));
assertEquals(false, exec("return false ^ false;"));
}
}

14
plugins/lang-plan-a/src/test/resources/rest-api-spec/test/plan_a/10_basic.yaml Normal file
View File

@ -0,0 +1,14 @@
# Integration tests for Plan A Plugin
#
"Plan A plugin loaded":
- do:
cluster.state: {}
# Get master node id
- set: { master_node: master }
- do:
nodes.info: {}
- match: { nodes.$master.plugins.0.name: lang-plan-a }
- match: { nodes.$master.plugins.0.jvm: true }

27
plugins/lang-plan-a/src/test/resources/rest-api-spec/test/plan_a/20_scriptfield.yaml Normal file
View File

@ -0,0 +1,27 @@
# Integration tests for using a scripted field
#
setup:
- do:
index:
index: test
type: test
id: 1
body: { "foo": "aaa" }
- do:
indices.refresh: {}
---
"Scripted Field":
- do:
search:
body:
script_fields:
bar:
script:
inline: "input.doc.foo.0 + input.x;"
lang: plan-a
params:
x: "bbb"
- match: { hits.hits.0.fields.bar.0: "aaabbb"}

97
plugins/lang-plan-a/src/test/resources/rest-api-spec/test/plan_a/30_search.yaml Normal file
View File

@ -0,0 +1,97 @@
# Integration tests for Plan-A search scripting
#
"Plan-A Query":
- do:
index:
index: test
type: test
id: 1
body: { "test": "value beck", "num1": 1.0 }
- do:
index:
index: test
type: test
id: 2
body: { "test": "value beck", "num1": 2.0 }
- do:
index:
index: test
type: test
id: 3
body: { "test": "value beck", "num1": 3.0 }
- do:
indices.refresh: {}
- do:
index: test
search:
body:
query:
script:
script:
inline: "input.doc.num1.0 > 1;"
lang: plan-a
script_fields:
sNum1:
script:
inline: "input.doc.num1.0;"
lang: plan-a
sort:
num1:
order: asc
- match: { hits.total: 2 }
- match: { hits.hits.0.fields.sNum1.0: 2.0 }
- match: { hits.hits.1.fields.sNum1.0: 3.0 }
- do:
index: test
search:
body:
query:
script:
script:
inline: "input.doc.num1.0 > input.param1;"
lang: plan-a
params:
param1: 1
script_fields:
sNum1:
script:
inline: "return input.doc.num1.0;"
lang: plan-a
sort:
num1:
order: asc
- match: { hits.total: 2 }
- match: { hits.hits.0.fields.sNum1.0: 2.0 }
- match: { hits.hits.1.fields.sNum1.0: 3.0 }
- do:
index: test
search:
body:
query:
script:
script:
inline: "input.doc.num1.0 > input.param1;"
lang: plan-a
params:
param1: -1
script_fields:
sNum1:
script:
inline: "input.doc.num1.0;"
lang: plan-a
sort:
num1:
order: asc
- match: { hits.total: 3 }
- match: { hits.hits.0.fields.sNum1.0: 1.0 }
- match: { hits.hits.1.fields.sNum1.0: 2.0 }
- match: { hits.hits.2.fields.sNum1.0: 3.0 }

1
qa/evil-tests/src/test/java/org/elasticsearch/plugins/PluginManagerTests.java
View File

@ -631,6 +631,7 @@ public class PluginManagerTests extends ESIntegTestCase {
PluginManager.checkForOfficialPlugins("analysis-stempel"); PluginManager.checkForOfficialPlugins("analysis-stempel");
PluginManager.checkForOfficialPlugins("delete-by-query"); PluginManager.checkForOfficialPlugins("delete-by-query");
PluginManager.checkForOfficialPlugins("lang-javascript"); PluginManager.checkForOfficialPlugins("lang-javascript");
PluginManager.checkForOfficialPlugins("lang-plan-a");
PluginManager.checkForOfficialPlugins("lang-python"); PluginManager.checkForOfficialPlugins("lang-python");
PluginManager.checkForOfficialPlugins("mapper-attachments"); PluginManager.checkForOfficialPlugins("mapper-attachments");
PluginManager.checkForOfficialPlugins("mapper-murmur3"); PluginManager.checkForOfficialPlugins("mapper-murmur3");

24
qa/vagrant/src/test/resources/packaging/scripts/plugin_test_cases.bash
View File

@ -223,6 +223,18 @@ fi
install_and_check_plugin discovery multicast install_and_check_plugin discovery multicast
} }
@test "[$GROUP] install lang-expression plugin" {
install_and_check_plugin lang expression
}
@test "[$GROUP] install lang-groovy plugin" {
install_and_check_plugin lang groovy
}
@test "[$GROUP] install lang-plan-a plugin" {
install_and_check_plugin lang plan-a
}
@test "[$GROUP] install javascript plugin" { @test "[$GROUP] install javascript plugin" {
install_and_check_plugin lang javascript rhino-*.jar install_and_check_plugin lang javascript rhino-*.jar
} }
@ -323,6 +335,18 @@ fi
remove_plugin discovery-multicast remove_plugin discovery-multicast
} }
@test "[$GROUP] remove lang-expression plugin" {
remove_plugin lang-expression
}
@test "[$GROUP] remove lang-groovy plugin" {
remove_plugin lang-groovy
}
@test "[$GROUP] remove lang-plan-a plugin" {
remove_plugin lang-plan-a
}
@test "[$GROUP] remove javascript plugin" { @test "[$GROUP] remove javascript plugin" {
remove_plugin lang-javascript remove_plugin lang-javascript
} }

1
settings.gradle
View File

@ -22,6 +22,7 @@ List projects = [
'plugins:discovery-gce', 'plugins:discovery-gce',
'plugins:discovery-multicast', 'plugins:discovery-multicast',
'plugins:lang-javascript', 'plugins:lang-javascript',
'plugins:lang-plan-a',
'plugins:lang-python', 'plugins:lang-python',
'plugins:mapper-attachments', 'plugins:mapper-attachments',
'plugins:mapper-murmur3', 'plugins:mapper-murmur3',