/********************************************************************************
 * Copyright (c) 2015-2019 Contributors to the Eclipse Foundation
 *
 * See the NOTICE file(s) distributed with this work for additional
 * information regarding copyright ownership.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 ********************************************************************************/

package org.eclipse.mdm.businessobjects.control.search;

import static org.assertj.core.api.Assertions.assertThat;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.BETWEEN;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.CASE_INSENSITIVE_EQUAL;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.CASE_INSENSITIVE_GREATER_THAN;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.CASE_INSENSITIVE_GREATER_THAN_OR_EQUAL;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.CASE_INSENSITIVE_IN_SET;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.CASE_INSENSITIVE_LESS_THAN;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.CASE_INSENSITIVE_LESS_THAN_OR_EQUAL;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.CASE_INSENSITIVE_LIKE;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.CASE_INSENSITIVE_NOT_EQUAL;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.CASE_INSENSITIVE_NOT_IN_SET;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.CASE_INSENSITIVE_NOT_LIKE;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.EQUAL;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.GREATER_THAN;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.GREATER_THAN_OR_EQUAL;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.IN_SET;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.IS_NOT_NULL;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.IS_NULL;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.LESS_THAN;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.LESS_THAN_OR_EQUAL;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.LIKE;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.NOT_EQUAL;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.NOT_IN_SET;
import static org.eclipse.mdm.api.base.query.ComparisonOperator.NOT_LIKE;
import static org.eclipse.mdm.businessobjects.control.FilterParser.parseFilterString;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.assertj.core.api.SoftAssertions;
import org.eclipse.mdm.api.base.adapter.EntityType;
import org.eclipse.mdm.api.base.query.ComparisonOperator;
import org.eclipse.mdm.api.base.query.Filter;
import org.junit.Test;

public class FilterParserTest {
	private List<EntityType> entities = SearchMockHelper.createETListMock();
	private Map<String, EntityType> map = entities.stream().collect(Collectors.toMap(EntityType::getName, e -> e));

	@Test
	public void testEmpty() throws Exception {
		assertThat(parseFilterString(entities, "").isEmtpty()).isTrue();
	}

	@Test
	public void testNull() throws Exception {
		assertThat(parseFilterString(entities, null).isEmtpty()).isTrue();
	}

	@Test
	public void testOperatorEqual() throws Exception {

		String filterString = "TestStep.Name eq 'test'";

		Filter expected = Filter.and()
				.add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("Name"), "test"));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorNotEqual() throws Exception {

		String filterString = "TestStep.Name ne 'test'";

		Filter expected = Filter.and().add(NOT_EQUAL.create(map.get("TestStep").getAttribute("Name"), "test"));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorLessThan() throws Exception {

		String filterString = "TestStep.LongAttribute lt 10";

		Filter expected = Filter.and().add(LESS_THAN.create(map.get("TestStep").getAttribute("LongAttribute"), 10L));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorLessThanOrEqual() throws Exception {

		String filterString = "TestStep.LongAttribute le 10";

		Filter expected = Filter.and()
				.add(LESS_THAN_OR_EQUAL.create(map.get("TestStep").getAttribute("LongAttribute"), 10L));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorGreaterThan() throws Exception {

		String filterString = "TestStep.LongAttribute gt 10";

		Filter expected = Filter.and().add(GREATER_THAN.create(map.get("TestStep").getAttribute("LongAttribute"), 10L));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorGreaterThanOrEqual() throws Exception {

		String filterString = "TestStep.LongAttribute ge 10";

		Filter expected = Filter.and()
				.add(GREATER_THAN_OR_EQUAL.create(map.get("TestStep").getAttribute("LongAttribute"), 10L));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorNotInSet() throws Exception {

		String filterString = "TestStep.Name not_in ('test', 'measurement', 'crash')";

		Filter expected = Filter.and().add(NOT_IN_SET.create(map.get("TestStep").getAttribute("Name"),
				new String[] { "test", "measurement", "crash" }));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorLike() throws Exception {

		String filterString = "TestStep.Name lk 'test*'";

		Filter expected = Filter.and().add(LIKE.create(map.get("TestStep").getAttribute("Name"), "test*"));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorNotLike() throws Exception {

		String filterString = "TestStep.Name not_lk 'test*'";

		Filter expected = Filter.and().add(NOT_LIKE.create(map.get("TestStep").getAttribute("Name"), "test*"));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorCIEqual() throws Exception {

		String filterString = "TestStep.Name ci_eq 'test'";

		Filter expected = Filter.and()
				.add(CASE_INSENSITIVE_EQUAL.create(map.get("TestStep").getAttribute("Name"), "test"));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorCINotEqual() throws Exception {

		String filterString = "TestStep.Name ci_ne 'test'";

		Filter expected = Filter.and()
				.add(CASE_INSENSITIVE_NOT_EQUAL.create(map.get("TestStep").getAttribute("Name"), "test"));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorCILessThan() throws Exception {

		String filterString = "TestStep.LongAttribute ci_lt 10";

		Filter expected = Filter.and()
				.add(CASE_INSENSITIVE_LESS_THAN.create(map.get("TestStep").getAttribute("LongAttribute"), 10L));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorCILessThanOrEqual() throws Exception {

		String filterString = "TestStep.LongAttribute ci_le 10";

		Filter expected = Filter.and().add(
				CASE_INSENSITIVE_LESS_THAN_OR_EQUAL.create(map.get("TestStep").getAttribute("LongAttribute"), 10L));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorCIGreaterThan() throws Exception {

		String filterString = "TestStep.LongAttribute ci_gt 10";

		Filter expected = Filter.and()
				.add(CASE_INSENSITIVE_GREATER_THAN.create(map.get("TestStep").getAttribute("LongAttribute"), 10L));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorCIGreaterThanOrEqual() throws Exception {

		String filterString = "TestStep.LongAttribute ci_ge 10";

		Filter expected = Filter.and().add(
				CASE_INSENSITIVE_GREATER_THAN_OR_EQUAL.create(map.get("TestStep").getAttribute("LongAttribute"), 10L));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorCIInSet() throws Exception {

		String filterString = "TestStep.Name ci_in ('test', 'measurement', 'crash')";

		Filter expected = Filter.and().add(CASE_INSENSITIVE_IN_SET.create(map.get("TestStep").getAttribute("Name"),
				new String[] { "test", "measurement", "crash" }));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorCINotInSet() throws Exception {

		String filterString = "TestStep.Name ci_not_in ('test', 'measurement', 'crash')";

		Filter expected = Filter.and().add(CASE_INSENSITIVE_NOT_IN_SET.create(map.get("TestStep").getAttribute("Name"),
				new String[] { "test", "measurement", "crash" }));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorCILike() throws Exception {

		String filterString = "TestStep.Name ci_lk 'test*'";

		Filter expected = Filter.and()
				.add(CASE_INSENSITIVE_LIKE.create(map.get("TestStep").getAttribute("Name"), "test*"));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorCINotLike() throws Exception {

		String filterString = "TestStep.Name ci_not_lk 'test*'";

		Filter expected = Filter.and()
				.add(CASE_INSENSITIVE_NOT_LIKE.create(map.get("TestStep").getAttribute("Name"), "test*"));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorIsNull() throws Exception {

		String filterString = "TestStep.Name is_null";

		Filter expected = Filter.and().add(IS_NULL.create(map.get("TestStep").getAttribute("Name"), null));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorIsNotNull() throws Exception {

		String filterString = "TestStep.Name is_not_null";

		Filter expected = Filter.and().add(IS_NOT_NULL.create(map.get("TestStep").getAttribute("Name"), null));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOperatorBetween() throws Exception {

		String filterString = "TestStep.LongAttribute bw (100, 1000)";

		Filter expected = Filter.and()
				.add(BETWEEN.create(map.get("TestStep").getAttribute("LongAttribute"), new long[] { 100, 1000 }));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testInSetWithImplicitToStringConversion() throws Exception {

		String filterString = "TestStep.Name in (12.2, 'test', 1)";

		Filter expected = Filter.and()
				.add(IN_SET.create(map.get("TestStep").getAttribute("Name"), new String[] { "12.2", "test", "1" }));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test(expected = NumberFormatException.class)
	public void testInSetWithStringForDoubleAttribute() throws Exception {

		String filterString = "TestStep.DoubleAttribute in (12.2, 'Test', 1)";

		Filter expected = Filter.and()
				.add(IN_SET.create(map.get("TestStep").getAttribute("DoubleAttribute"), new double[] { 12.2 }));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testInSetWithNumericDataTypes() throws Exception {

		String filterString = "TestStep.DoubleAttribute in (12.2, -1.0, 0.006022)";

		Filter expected = Filter.and().add(IN_SET.create(map.get("TestStep").getAttribute("DoubleAttribute"),
				new double[] { 12.2, -1.0, 0.006022 }));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testSimple() throws Exception {

		String filterString = "TestStep.Name eq 'test'";

		Filter expected = Filter.and()
				.add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("Name"), "test"));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testSimpleWithBrackets() throws Exception {

		String filterString = "(TestStep.Name eq 'test')";

		Filter expected = Filter.and()
				.add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("Name"), "test"));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testOr() throws Exception {

		String filterString = "(TestStep.Name eq 'test') or (Test.LongAttribute gt 1)";

		Filter expected = Filter.or()
				.add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("Name"), "test"))
				.add(ComparisonOperator.GREATER_THAN.create(map.get("Test").getAttribute("LongAttribute"), 1L));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testAnd() throws Exception {

		String filterString = "(TestStep.Name eq 'test') and (Test.LongAttribute gt 1)";

		Filter expected = Filter.and()
				.add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("Name"), "test"))
				.add(ComparisonOperator.GREATER_THAN.create(map.get("Test").getAttribute("LongAttribute"), 1L));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testAnd2() throws Exception {

		String filterString = "TestStep.Name eq 'test' and Test.LongAttribute gt 1";

		Filter expected = Filter.and()
				.add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("Name"), "test"))
				.add(ComparisonOperator.GREATER_THAN.create(map.get("Test").getAttribute("LongAttribute"), 1L));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testSimpleNot() throws Exception {

		String filterString = "not(TestStep.Name eq 'test')";

		Filter expected = Filter.and()
				.add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("Name"), "test")).invert();

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testNot() throws Exception {

		String filterString = "TestStep.Name eq 'test' and not(Test.LongAttribute gt 1)";

		Filter expected = Filter.and()
				.add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("Name"), "test"))
				.merge(Filter.or()
						.add(ComparisonOperator.GREATER_THAN.create(map.get("Test").getAttribute("LongAttribute"), 1L))
						.invert());

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testNested() throws Exception {

		String filterString = "TestStep.Name eq 'test' and (Test.LongAttribute gt 1 or Test.IntegerAttribute lt 10)";

		Filter expected = Filter.and()
				.add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("Name"), "test"))
				.merge(Filter.or()
						.add(ComparisonOperator.GREATER_THAN.create(map.get("Test").getAttribute("LongAttribute"), 1L))
						.add(ComparisonOperator.LESS_THAN.create(map.get("Test").getAttribute("IntegerAttribute"),
								10)));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testCaseOfKeywordsIsIgnored() throws Exception {

		String filterString = "TestStep.Name Eq 'test' AND (Test.LongAttribute gt 1 oR Test.IntegerAttribute LT 10)";

		Filter expected = Filter.and()
				.add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("Name"), "test"))
				.merge(Filter.or()
						.add(ComparisonOperator.GREATER_THAN.create(map.get("Test").getAttribute("LongAttribute"), 1L))
						.add(ComparisonOperator.LESS_THAN.create(map.get("Test").getAttribute("IntegerAttribute"),
								10)));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testAndPrecedence() throws Exception {

		String filterString = "TestStep.Name eq 'test' and Test.LongAttribute gt 1 or Test.IntegerAttribute lt 10";

		Filter expected = Filter.or().merge(
				Filter.and().add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("Name"), "test"))
						.add(ComparisonOperator.GREATER_THAN.create(map.get("Test").getAttribute("LongAttribute"), 1L)),
				Filter.and().add(
						ComparisonOperator.LESS_THAN.create(map.get("Test").getAttribute("IntegerAttribute"), 10)));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testAndPrecedence2() throws Exception {

		String filterString = "TestStep.Name eq 'test' or Test.LongAttribute gt 1 and Test.IntegerAttribute lt 10";

		Filter expected = Filter.or().merge(
				Filter.and().add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("Name"), "test")),
				Filter.and()
						.add(ComparisonOperator.GREATER_THAN.create(map.get("Test").getAttribute("LongAttribute"), 1L))
						.add(ComparisonOperator.LESS_THAN.create(map.get("Test").getAttribute("IntegerAttribute"),
								10)));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testComplexFilter() throws Exception {

		String filterString = "TestStep.Name eq 'test' and (Test.LongAttribute gt 1 or Test.DoubleAttribute lt 12.3 or Test.IntegerAttribute eq 2) "
				+ " and not(TestStep.FloatAttribute gt 3.14 or TestStep.BooleanAttribute eq true) or TestStep.DateAttribute gt '2017-01-02T01:02:03'";

		Filter expected = Filter
				.or().merge(
						Filter.and()
								.add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("Name"), "test"))
								.merge(Filter.or()
										.add(ComparisonOperator.GREATER_THAN
												.create(map.get("Test").getAttribute("LongAttribute"), 1L))
										.add(ComparisonOperator.LESS_THAN
												.create(map.get("Test").getAttribute("DoubleAttribute"), 12.3))
										.add(ComparisonOperator.EQUAL
												.create(map.get("Test").getAttribute("IntegerAttribute"), 2)),
										Filter.or()
												.add(ComparisonOperator.GREATER_THAN.create(
														map.get("TestStep").getAttribute("FloatAttribute"), 3.14f))
												.add(ComparisonOperator.EQUAL.create(
														map.get("TestStep").getAttribute("BooleanAttribute"), true))
												.invert()),
						Filter.and()
								.add(ComparisonOperator.GREATER_THAN.create(
										map.get("TestStep").getAttribute("DateAttribute"),
										LocalDateTime.parse("2017-01-02T01:02:03"))));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testDataTypeString() throws Exception {
		String filterString = "TestStep.Name eq 'Test'";

		Filter expected = Filter.and()
				.add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("Name"), "Test"));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testDataTypeDate() throws Exception {
		String filterString = "TestStep.DateAttribute gt '2017-09-28T12:13:14'";

		Filter expected = Filter.and().add(ComparisonOperator.GREATER_THAN
				.create(map.get("TestStep").getAttribute("DateAttribute"), LocalDateTime.parse("2017-09-28T12:13:14")));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testDataTypeDateWithMillies() throws Exception {
		String filterString = "TestStep.DateAttribute gt '2017-09-29T12:13:14.123456'";

		Filter expected = Filter.and().add(ComparisonOperator.GREATER_THAN.create(
				map.get("TestStep").getAttribute("DateAttribute"), LocalDateTime.parse("2017-09-29T12:13:14.123456")));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testDataTypeDateSequence() throws Exception {
		String filterString = "TestStep.DateAttribute bw ('2017-09-28T12:13:14', '2017-09-29T17:18:19')";

		Filter expected = Filter.and()
				.add(ComparisonOperator.BETWEEN.create(map.get("TestStep").getAttribute("DateAttribute"),
						new LocalDateTime[] { LocalDateTime.parse("2017-09-28T12:13:14"),
								LocalDateTime.parse("2017-09-29T17:18:19") }));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testDataTypeBoolean() throws Exception {
		String filterString = "TestStep.BooleanAttribute eq true";

		Filter expected = Filter.and()
				.add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("BooleanAttribute"), true));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testDataTypeByte() throws Exception {
		String filterString = "TestStep.ByteAttribute eq 127";

		Filter expected = Filter.and()
				.add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("ByteAttribute"), (byte) 127));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testDataTypeShort() throws Exception {
		String filterString = "TestStep.ShortAttribute eq 1024";

		Filter expected = Filter.and()
				.add(ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("ShortAttribute"), (short) 1024));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testDataTypeInteger() throws Exception {
		String filterString = "TestStep.IntegerAttribute eq " + Integer.MAX_VALUE;

		Filter expected = Filter.and().add(ComparisonOperator.EQUAL
				.create(map.get("TestStep").getAttribute("IntegerAttribute"), Integer.MAX_VALUE));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testDataTypeLong() throws Exception {
		String filterString = "TestStep.LongAttribute eq " + Long.MAX_VALUE;

		Filter expected = Filter.and().add(
				ComparisonOperator.EQUAL.create(map.get("TestStep").getAttribute("LongAttribute"), Long.MAX_VALUE));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testDataTypeFloat() throws Exception {
		String filterString = "TestStep.FloatAttribute gt 12.3";

		Filter expected = Filter.and()
				.add(ComparisonOperator.GREATER_THAN.create(map.get("TestStep").getAttribute("FloatAttribute"), 12.3f));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testDataTypeDouble() throws Exception {
		String filterString = "TestStep.DoubleAttribute gt 12.2";

		Filter expected = Filter.and()
				.add(ComparisonOperator.GREATER_THAN.create(map.get("TestStep").getAttribute("DoubleAttribute"), 12.2));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testKeywordsInValue() throws Exception {
		String filterString = "Test.Name eq 'y eq z and not(x)'";

		Filter expected = Filter.and().add(EQUAL.create(map.get("Test").getAttribute("Name"), "y eq z and not(x)"));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testEscapedQuotesInValue() throws Exception {
		String filterString = "Test.Name eq 'Test \\'abc\\' 2'";

		Filter expected = Filter.and().add(EQUAL.create(map.get("Test").getAttribute("Name"), "Test 'abc' 2"));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testEscapedDoubleQuotesInValue() throws Exception {
		String filterString = "Test.Name eq 'Test \"abc\"'";

		Filter expected = Filter.and().add(EQUAL.create(map.get("Test").getAttribute("Name"), "Test \"abc\""));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testBackslashInValue() throws Exception {
		String filterString = "Test.Name eq 'c:\\Temp'";

		Filter expected = Filter.and().add(EQUAL.create(map.get("Test").getAttribute("Name"), "c:\\Temp"));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testNewlineInValue() throws Exception {
		String filterString = "Test.Name eq 'new\nline'";

		Filter expected = Filter.and().add(EQUAL.create(map.get("Test").getAttribute("Name"), "new\nline"));

		assertThat(parseFilterString(entities, filterString)).isEqualTo(expected);
	}

	@Test
	public void testInvalidFilterStrings() {
		SoftAssertions softly = new SoftAssertions();

		softly.assertThatThrownBy(() -> parseFilterString(entities, "xyz")).isInstanceOf(IllegalArgumentException.class)
				.hasMessageStartingWith("Could not parse filter string");

		softly.assertThatThrownBy(() -> parseFilterString(entities, "and")).isInstanceOf(IllegalArgumentException.class)
				.hasMessageStartingWith("Could not parse filter string");

		softly.assertThatThrownBy(() -> parseFilterString(entities, "x eq y"))
				.isInstanceOf(IllegalArgumentException.class).hasMessageStartingWith("Could not parse filter string");

		softly.assertThatThrownBy(() -> parseFilterString(entities, "Test.Name eq y"))
				.isInstanceOf(IllegalArgumentException.class).hasMessageStartingWith("Could not parse filter string");

		softly.assertThatThrownBy(() -> parseFilterString(entities, "((Test.Name eq 'y')"))
				.isInstanceOf(IllegalArgumentException.class).hasMessageStartingWith("Could not parse filter string");

		softly.assertThatThrownBy(() -> parseFilterString(entities, "Test.Name eq 'y' and Test.Name lt 'x')"))
				.isInstanceOf(IllegalArgumentException.class).hasMessageStartingWith("Could not parse filter string");

		softly.assertThatThrownBy(() -> parseFilterString(entities, "x.y eq 'z'"))
				.isInstanceOf(IllegalArgumentException.class)
				.hasMessageStartingWith("Entity x not found in data source");

		softly.assertAll();
	}
}