import {
	IInsightFacade,
	InsightDatasetKind,
	InsightError,
	InsightResult,
	NotFoundError,
	ResultTooLargeError,
} from "../../src/controller/IInsightFacade";
import InsightFacade from "../../src/controller/InsightFacade";
import { clearDisk, getContentFromArchives, loadTestQuery } from "../TestUtil";

import { expect, use } from "chai";
import chaiAsPromised from "chai-as-promised";

use(chaiAsPromised);

export interface ITestQuery {
	title?: string; // Test case title
	input: unknown; // Query under test
	errorExpected: boolean; // Whether the query is expected to throw an error
	expected: any; // Expected result
	orderExpected: boolean;
	orderBy: string[];
}

describe("InsightFacadeNam", function () {
	let facade: IInsightFacade;
	// Declare datasets used in tests. You should add more datasets like this!
	let sections: string;
	let sectionsQuery: string;
	let noResKey: string;
	let noSections: string;
	let notCoursesFolder: string;
	let notEveryMfield: string;
	let notEverySfield: string;
	let notJsonFormat: string;
	let campus: string;
	let campusSmall: string;
	let campusIndex: string;
	let campusRoom: string;

	// let fiveK: string;
	// let fiveKminusOne: string;
	// let fiveKone: string;

	before(async function () {
		// This block runs once and loads the datasets.
		campus = await getContentFromArchives("campus.zip");
		sections = await getContentFromArchives("validSmallData.zip");
		sectionsQuery = await getContentFromArchives("pairCourses.zip");
		noResKey = await getContentFromArchives("noResKey.zip");
		noSections = await getContentFromArchives("noSections.zip");
		notCoursesFolder = await getContentFromArchives("notCoursesFolder.zip");
		notEveryMfield = await getContentFromArchives("notEveryMfield.zip");
		notEverySfield = await getContentFromArchives("notEverySfield.zip");
		notJsonFormat = await getContentFromArchives("notJsonFormat.zip");
		campusSmall = await getContentFromArchives("campusSmall.zip");
		campusIndex = await getContentFromArchives("campusIndex.zip");
		campusRoom = await getContentFromArchives("campusRoom.zip");
		// fiveK = await getContentFromArchives("fiveK.zip");
		// fiveKminusOne = await getContentFromArchives("fiveKminusOne.zip");
		// fiveKone = await getContentFromArchives("fiveKone.zip");
		// Just in case there is anything hanging around from a previous run of the test suite
		await clearDisk();
	});

	describe("AddDataset", function () {
		beforeEach(async function () {
			await clearDisk();
			facade = new InsightFacade();
		});

		it("should successfully add a dataset (first)", async function () {
			try {
				//const facade2: InsightFacade = new InsightFacade();
				const result = await facade.addDataset("ubc", sections, InsightDatasetKind.Sections);
				//const result = await facade2.addDataset("ubc", campus, InsightDatasetKind.Rooms);
				expect(result).to.have.members(["ubc"]);
				// console.log(Object.fromEntries(facade2.getDataset()));

				// const fs = require("fs-extra");
				// const res = await fs.readJson("data/" + "ubc" + ".json");
				// console.log(res);
				// console.log(typeof res);
				// console.log(typeof res[0]);
				// console.log(res[0]);
				// console.log(res[0].avg);
				//console.log(res[0].getSectionField("avg")); //is wrong. saved class as object without class functions.
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should successfully add a dataset (second)", async function () {
			try {
				const result = await facade.addDataset("ubc", sections, InsightDatasetKind.Sections);
				expect(result).to.have.members(["ubc"]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should reject valid sections kind but invalid rooms dataset kind", async function () {
			try {
				await facade.addDataset("ubc", campus, InsightDatasetKind.Sections);
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});

		it("should reject valid rooms kind but invalid sections dataset kind", async function () {
			try {
				await facade.addDataset("ubc", sections, InsightDatasetKind.Rooms);
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});

		it("should successfully add a small Rooms dataset", async function () {
			try {
				const result = await facade.addDataset("ubc", campusSmall, InsightDatasetKind.Rooms);
				expect(result).to.have.members(["ubc"]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should successfully add a Rooms dataset with one bad index", async function () {
			try {
				const result = await facade.addDataset("ubc", campusIndex, InsightDatasetKind.Rooms);
				expect(result).to.have.members(["ubc"]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should successfully add a Rooms dataset with one bad room", async function () {
			try {
				const result = await facade.addDataset("ubc", campusRoom, InsightDatasetKind.Rooms);
				expect(result).to.have.members(["ubc"]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should successfully add a Sections dataset", async function () {
			try {
				const result = await facade.addDataset("ubc", sectionsQuery, InsightDatasetKind.Sections);
				expect(result).to.have.members(["ubc"]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should successfully add a dataset chain", async function () {
			try {
				const result = await facade.addDataset("ubc", sections, InsightDatasetKind.Sections).then(async () => {
					return await facade.addDataset("ufc", sections, InsightDatasetKind.Sections);
				});
				expect(result).to.have.members(["ubc", "ufc"]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should reject with an empty dataset id Nam", async function () {
			try {
				await facade.addDataset("", sections, InsightDatasetKind.Sections);
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});

		it("should reject with an whitespace dataset id", async function () {
			try {
				await facade.addDataset("     ", sections, InsightDatasetKind.Sections);
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});

		it("should reject with a duplicate dataset id", async function () {
			try {
				await facade.addDataset("ubc", sections, InsightDatasetKind.Sections).then(async () => {
					return await facade.addDataset("ubc", sections, InsightDatasetKind.Sections);
				});
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});

		it("should reject with a duplicate dataset id and not change set", async function () {
			try {
				await facade.addDataset("ubc", sections, InsightDatasetKind.Sections).then(async () => {
					return await facade.addDataset("ubc", sections, InsightDatasetKind.Sections);
				});
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
				try {
					const result = await facade.addDataset("ufc", sections, InsightDatasetKind.Sections);
					expect(result).to.have.members(["ubc", "ufc"]);
				} catch (mistake) {
					expect.fail(`Should not have thrown ${mistake}!`);
				}
			}
		});

		it("should reject with an underscore dataset id", async function () {
			try {
				await facade.addDataset("ubc_", sections, InsightDatasetKind.Sections);
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});

		it("should reject with not base64 string content", async function () {
			try {
				const content = "invalid content";
				await facade.addDataset("ubc", content, InsightDatasetKind.Sections);
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});

		it("should successfully add a dataset through disk, should save on disk", async function () {
			try {
				await facade.addDataset("ubc", sections, InsightDatasetKind.Sections);
				facade = new InsightFacade();
				const result = await facade.addDataset("ufc", sections, InsightDatasetKind.Sections);
				expect(result).to.have.members(["ubc", "ufc"]);
				const facadeTemp: IInsightFacade = new InsightFacade();
				const arr = await facadeTemp.addDataset("unc", sections, InsightDatasetKind.Sections);
				expect(arr).to.have.members(["ubc", "ufc", "unc"]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should reject content without result key", async function () {
			try {
				await facade.addDataset("ubc", noResKey, InsightDatasetKind.Sections);
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});

		it("should reject content without sections", async function () {
			try {
				await facade.addDataset("ubc", noSections, InsightDatasetKind.Sections);
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});

		it("should reject content without courses folder", async function () {
			try {
				await facade.addDataset("ubc", notCoursesFolder, InsightDatasetKind.Sections);
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});

		it("should reject content without every mfield", async function () {
			try {
				await facade.addDataset("ubc", notEveryMfield, InsightDatasetKind.Sections);
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});

		it("should reject content without every sfield", async function () {
			try {
				await facade.addDataset("ubc", notEverySfield, InsightDatasetKind.Sections);
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});

		it("should reject content without json format", async function () {
			try {
				await facade.addDataset("ubc", notJsonFormat, InsightDatasetKind.Sections);
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});
	});

	describe("RemoveDataset", function () {
		beforeEach(async function () {
			await clearDisk();
			facade = new InsightFacade();
		});

		it("should successfully remove a dataset (first)", async function () {
			try {
				await facade.addDataset("ubc", sections, InsightDatasetKind.Sections);

				const result = await facade.removeDataset("ubc");
				expect(result).to.be.equal("ubc");

				const arr = await facade.addDataset("unc", sections, InsightDatasetKind.Sections);
				expect(arr).to.have.members(["unc"]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should successfully remove a dataset (second)", async function () {
			try {
				await facade.addDataset("ubc", sections, InsightDatasetKind.Sections);

				const result = await facade.removeDataset("ubc");
				expect(result).to.be.equal("ubc");

				const arr = await facade.addDataset("unc", sections, InsightDatasetKind.Sections);
				expect(arr).to.have.members(["unc"]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should successfully remove partially a dataset chain", async function () {
			try {
				await facade.addDataset("ubc", sections, InsightDatasetKind.Sections).then(async () => {
					return await facade.addDataset("ufc", sections, InsightDatasetKind.Sections);
				});

				const result = await facade.removeDataset("ubc");
				expect(result).to.be.equal("ubc");

				const arr = await facade.addDataset("unc", sections, InsightDatasetKind.Sections);
				expect(arr).to.have.members(["unc", "ufc"]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should successfully remove a dataset chain", async function () {
			try {
				await facade.addDataset("ubc", sections, InsightDatasetKind.Sections).then(async () => {
					return await facade.addDataset("ufc", sections, InsightDatasetKind.Sections);
				});

				await facade.removeDataset("ubc");
				const result = await facade.removeDataset("ufc");
				expect(result).to.be.equal("ufc");

				const arr = await facade.addDataset("unc", sections, InsightDatasetKind.Sections);
				expect(arr).to.have.members(["unc"]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should reject remove with an non-existing valid dataset id", async function () {
			try {
				await facade.removeDataset("ubc");
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(NotFoundError);
			}
		});

		// it("should reject remove with an non-existing valid dataset id after add", async function () {
		// 	//don't know why
		// 	try {
		// 		await facade.addDataset("ubc", sections, InsightDatasetKind.Sections);
		// 		await facade.removeDataset("unc");
		// 		expect.fail("Should have thrown!");
		// 	} catch (err) {
		// 		expect(err).to.be.instanceOf(NotFoundError);
		// 	}
		// });

		it("should reject remove with an underscore id", async function () {
			try {
				await facade.removeDataset("ubc_");
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});

		it("should reject remove with an empty id", async function () {
			try {
				await facade.removeDataset("");
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});

		it("should reject remove with a whitespace id", async function () {
			try {
				await facade.removeDataset("     ");
				expect.fail("Should have thrown!");
			} catch (err) {
				expect(err).to.be.instanceOf(InsightError);
			}
		});

		// it("should successfully remove a dataset from disk, cache", async function () {
		// 	//don't know why
		// 	try {
		// 		await facade
		// 			.addDataset("ubc", sections, InsightDatasetKind.Sections)
		// 			.then(async () => {
		// 				await facade.addDataset("ufc", sections, InsightDatasetKind.Sections);
		// 			})
		// 			.then(async () => {
		// 				await facade.addDataset("unc", sections, InsightDatasetKind.Sections);
		// 			});

		// 		await facade.removeDataset("ubc");

		// 		facade = new InsightFacade();
		// 		const result = await facade.removeDataset("ufc");
		// 		expect(result).to.be.equal("ufc");

		// 		const facadeTemp: IInsightFacade = new InsightFacade();
		// 		const arr = await facadeTemp.removeDataset("unc");
		// 		expect(arr).to.be.equal("unc");
		// 	} catch (err) {
		// 		expect.fail(`Should not have thrown ${err}!`);
		// 	}
		// });
	});

	describe("ListDatasets", function () {
		beforeEach(async function () {
			await clearDisk();
			facade = new InsightFacade();
		});

		it("should successfully list a dataset 0", async function () {
			try {
				const result = await facade.listDatasets();
				expect(result).to.deep.equal([]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should successfully list a dataset 1", async function () {
			try {
				await facade.addDataset("ubc", sections, InsightDatasetKind.Sections);

				const result = await facade.listDatasets();
				expect(result).to.deep.equal([
					{
						id: "ubc",
						kind: InsightDatasetKind.Sections,
						numRows: 6,
					},
				]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should successfully list a dataset 2", async function () {
			try {
				await facade.addDataset("ubc", sections, InsightDatasetKind.Sections).then(async () => {
					return await facade.addDataset("ufc", sections, InsightDatasetKind.Sections);
				});

				const result = await facade.listDatasets();
				expect(result).to.deep.equal([
					{
						id: "ubc",
						kind: InsightDatasetKind.Sections,
						numRows: 6,
					},
					{
						id: "ufc",
						kind: InsightDatasetKind.Sections,
						numRows: 6,
					},
				]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should successfully list a dataset 0 chain", async function () {
			try {
				const result = await facade.listDatasets();
				expect(result).to.deep.equal([]);
				const arr = await facade.listDatasets();
				expect(arr).to.deep.equal([]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should successfully list a dataset 1 chain", async function () {
			try {
				await facade.addDataset("ubc", sections, InsightDatasetKind.Sections);

				const expected = [
					{
						id: "ubc",
						kind: InsightDatasetKind.Sections,
						numRows: 6,
					},
				];

				const result = await facade.listDatasets();
				expect(result).to.deep.equal(expected);

				const arr = await facade.listDatasets();
				expect(arr).to.deep.equal(expected);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should successfully list a dataset 2 chain", async function () {
			try {
				await facade.addDataset("ubc", sections, InsightDatasetKind.Sections).then(async () => {
					return await facade.addDataset("ufc", sections, InsightDatasetKind.Sections);
				});

				const expected = [
					{
						id: "ubc",
						kind: InsightDatasetKind.Sections,
						numRows: 6,
					},
					{
						id: "ufc",
						kind: InsightDatasetKind.Sections,
						numRows: 6,
					},
				];

				const result = await facade.listDatasets();
				expect(result).to.deep.equal(expected);

				const arr = await facade.listDatasets();
				expect(arr).to.deep.equal(expected);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});

		it("should successfully list a dataset after removal", async function () {
			try {
				await facade.addDataset("ubc", sections, InsightDatasetKind.Sections).then(async () => {
					return await facade.addDataset("ufc", sections, InsightDatasetKind.Sections);
				});

				const expected = [
					{
						id: "ubc",
						kind: InsightDatasetKind.Sections,
						numRows: 6,
					},
					{
						id: "ufc",
						kind: InsightDatasetKind.Sections,
						numRows: 6,
					},
				];

				const result = await facade.listDatasets();
				expect(result).to.deep.equal(expected);

				await facade.removeDataset("ubc");

				const arr = await facade.listDatasets();
				expect(arr).to.deep.equal([
					{
						id: "ufc",
						kind: InsightDatasetKind.Sections,
						numRows: 6,
					},
				]);
			} catch (err) {
				expect.fail(`Should not have thrown ${err}!`);
			}
		});
	});

	describe("PerformQuery", function () {
		/**
		 * Loads the TestQuery specified in the test name and asserts the behaviour of performQuery.
		 *
		 * Note: the 'this' parameter is automatically set by Mocha and contains information about the test.
		 */
		async function checkQuery(this: Mocha.Context): Promise<void> {
			if (!this.test) {
				throw new Error(
					"Invalid call to checkQuery." +
						"Usage: 'checkQuery' must be passed as the second parameter of Mocha's it(..) function." +
						"Do not invoke the function directly."
				);
			}
			// Destructuring assignment to reduce property accesses
			const { input, expected, errorExpected, orderExpected, orderBy } = await loadTestQuery(this.test.title);
			//console.log(typeof input); input is an Object
			let result: InsightResult[] = []; // dummy value before being reassigned
			try {
				result = await facade.performQuery(input);
			} catch (err) {
				if (!errorExpected) {
					expect.fail(`performQuery threw unexpected error: ${err}`);
				}
				const errorClassMap: Record<string, any> = {
					InsightError,
					NotFoundError,
					ResultTooLargeError,
				};
				const expectedError = errorClassMap[expected];
				expect(err).to.be.instanceOf(expectedError);
				return;
			}
			if (errorExpected) {
				expect.fail(`performQuery resolved when it should have rejected with ${expected}`);
			}
			//expect(result).to.deep.equal(expected);
			expect(result).to.have.deep.members(expected);
			expect(result).to.have.length(expected.length);
			if (orderExpected) {
				const resultAvg = result.map((item) => orderBy.map((key) => item[key]));
				const expectedAvg = expected.map((item: InsightResult) => orderBy.map((key) => item[key]));
				expect(resultAvg).to.deep.equal(expectedAvg);
			}
			return;
		}

		before(async function () {
			facade = new InsightFacade();

			// Add the datasets to InsightFacade once.
			// Will *fail* if there is a problem reading ANY dataset.
			const loadDatasetPromises: Promise<string[]>[] = [
				facade.addDataset("sections", sectionsQuery, InsightDatasetKind.Sections),
			];

			try {
				await Promise.all(loadDatasetPromises);
			} catch (err) {
				throw new Error(`In PerformQuery Before hook, dataset(s) failed to be added. \n${err}`);
			}
		});

		after(async function () {
			await clearDisk();
		});

		// Examples demonstrating how to test performQuery using the JSON Test Queries.
		// The relative path to the query file must be given in square brackets.
		it("[valid/simpleTest.json] SELECT dept, avg WHERE avg > 97 Nam", checkQuery);
		it("[valid/asterixAll.json] asterisk around", checkQuery);
		it("[valid/asterixEnd.json]asterisk before", checkQuery);
		it("[valid/asterixNo.json] no asterisk, normal s comparison", checkQuery);
		it("[valid/asterixStart.json] asterisk after", checkQuery);
		it("[valid/complexTest.json] complex SELECT", checkQuery);
		it("[valid/unordered.json] no order in options", checkQuery); //the only test without order key
		// Reason why test suite couldn't catch 16th mutant is because 16th one was probably related to ordering
		it("[valid/emptyString.json] s comparision should accept any string without asterix", checkQuery);
		it("[valid/filterAND.json] SELECT with and", checkQuery);
		it("[valid/filterDoubleNOT.json] SELECT with double not", checkQuery);
		it("[valid/filterEQ.json] SELECT dept, avg WHERE avg = 97", checkQuery);
		it("[valid/filterLT.json] SELECT dept, avg WHERE avg < 97", checkQuery);
		it("[valid/filterNot.json] SELECT with not", checkQuery);
		it("[valid/filterOR.json] SELECT with or", checkQuery);
		it("[valid/simpleAND.json] simpleAND", checkQuery);
		it("[valid/simpleAudit.json] simpleAudit", checkQuery);
		it("[valid/simpleDept.json] simpleDept", checkQuery);
		it("[valid/simpleFail.json] simpleFail", checkQuery);
		it("[valid/simpleID.json] simpleID", checkQuery);
		it("[valid/simpleInstr.json] simpleInstr", checkQuery);
		it("[valid/simpleNOT.json] simpleNOT", checkQuery);
		it("[valid/simpleNumberBoundaryHundred.json] simpleNumberBoundaryHundred", checkQuery);
		it("[valid/simpleNumberBoundaryHundredOne.json] simpleNumberBoundaryHundredOne", checkQuery);
		it("[valid/simpleNumberBoundaryMinus.json] simpleNumberBoundaryMinus", checkQuery);
		it("[valid/simpleNumberBoundaryNineNine.json] simpleNumberBoundaryNineNine", checkQuery);
		it("[valid/simpleNumberBoundaryOne.json] simpleNumberBoundaryOne", checkQuery);
		it("[valid/simpleOR.json] simpleOR", checkQuery);
		it("[valid/simplePass.json] simplePass", checkQuery);
		it("[valid/simpleTitle.json] simpleTitle", checkQuery);
		it("[valid/simpleUUID.json] simpleUUID", checkQuery);
		it("[valid/contradictionShouldGiveNothing.json] contradictionShouldGiveNothing", checkQuery);
		it("[valid/contradictionShouldGiveNothingOR.json] contradictionShouldGiveNothingOR", checkQuery);
		it("[valid/nestedLogic.json] nestedLogic", checkQuery);
		it("[valid/notEverythingIsNothing.json] notEverythingIsNothing", checkQuery);
		it("[valid/overrideInvalidOptionsWithValidOptions.json] overrideInvalidOptionsWithValidOptions", checkQuery);
		it("[valid/overrideInvalidWhereWithValidWhere.json] overrideInvalidWhereWithValidWhere", checkQuery);
		it("[valid/oRDEROVERRIDE.json] oRDEROVERRIDE", checkQuery);
		it("[valid/oRDERANDCOLUMNSSWAPPED.json] oRDERANDCOLUMNSSWAPPED", checkQuery);
		it("[valid/repeatinColumnsIsOk.json] repeatinColumnsIsOk", checkQuery);
		it("[valid/reverseOptionsWhere.json] reverseOptionsWhere", checkQuery);
		it("[valid/zeroNumberIsAcceptable.json] zeroNumberIsAcceptable", checkQuery);
		it("[valid/aLLKEYSAlsoCheckThatItFlipsYearIfOVERALL.json] aLLKEYSAlsoCheckThatItFlipsYearIfOVERALL", checkQuery);
		it("[valid/fILTEROVERRIDE.json] fILTEROVERRIDE", checkQuery);
		it("[valid/negativeNumberIsAcceptable.json] negativeNumberIsAcceptable", checkQuery);
		it("[valid/onlyTwoAsterisk.json] onlyTwoAsterisk", checkQuery);
		it("[valid/onlyOneAsterisk.json] onlyOneAsterisk", checkQuery);
		it("[valid/simpleANDAdj.json] simpleANDAdj", checkQuery);
		it("[valid/simpleNOTAND.json] simpleNOTAND", checkQuery);
		it("[valid/simpleNOTANDSingle.json] simpleNOTANDSingle", checkQuery);
		it("[valid/simpleNOTOR.json] simpleNOTOR", checkQuery);
		it("[valid/simpleNOTORSingle.json] simpleNOTORSingle", checkQuery);
		it("[valid/simpleORUnion.json] simpleORUnion", checkQuery);
		it("[valid/bOTHWHEREOPTIONSOVERRIDE.json] bOTHWHEREOPTIONSOVERRIDE", checkQuery);
		it(
			"[valid/countsEveryCharacterWhitespaceTooInStrings.json] countsEveryCharacterWhitespaceTooInStrings",
			checkQuery
		);
		//it("[valid/simpleYear.json] simpleYear", checkQuery); //
		//it("[valid/takesExactlyFiveThousands.json] takesExactlyFiveThousands", checkQuery); //
		//it("[valid/takesExactlyFiveThousandsMinusOne.json] takesExactlyFiveThousandsMinusOne", checkQuery); //
		//it("[valid/aNDCanHaveOneKey.json] aNDCanHaveOneKey", checkQuery); //
		//it("[valid/oRCanHaveOneKey.json] oRCanHaveOneKey", checkQuery); //

		it("[invalid/missingWhere.json] Query missing WHERE", checkQuery);
		it("[invalid/missingOptions.json] Query missing OPTIONS", checkQuery);
		it("[invalid/largeError.json] More than loadable amount", checkQuery);
		it("[invalid/andFilterListEmpty.json] and is empty", checkQuery);
		it("[invalid/orFilterListEmpty.json] or is empty", checkQuery);
		it("[invalid/columnsEmpty.json] COLUMNS is empty", checkQuery);
		it("[invalid/doubleAsterisk.json] two consecutive asterisk", checkQuery);
		it("[invalid/middleAsterix.json] asterisk in the middle of string", checkQuery);
		it("[invalid/emptyIdString.json] empty id", checkQuery);
		it("[invalid/underscoreIdString.json] id with underscore", checkQuery);
		it("[invalid/invalidFilterFieldKeyNonExisting.json] key is not given in sfield/mfield", checkQuery);
		it("[invalid/invalidFilterFieldKeyType.json] mixed sfield and mfield", checkQuery);
		it("[invalid/invalidFilterKey.json] not a filter type", checkQuery);
		it("[invalid/invalidOptionsList.json] invalid options", checkQuery);
		it("[invalid/invalidTypeForM.json] string instad of number", checkQuery);
		it("[invalid/invalidTypeForS.json] number instad of string", checkQuery);
		it("[invalid/notObject.json] not acceptable format", checkQuery);
		it("[invalid/orderKeyNotInColumns.json] columns are ordered by not added key", checkQuery);
		it("[invalid/referencesNotAddedDataset.json] not existing dataset id", checkQuery);
		it("[invalid/referencesTwoDatasets.json]two dataset id's", checkQuery);
		it("[invalid/aNDMustBeANonEmptyArray.json] aNDMustBeANonEmptyArray", checkQuery);
		it("[invalid/aNDMustBeObject.json] aNDMustBeObject", checkQuery);
		it("[invalid/aNDShouldOnlyHaveOneKeyHasTwo.json] aNDShouldOnlyHaveOneKeyHasTwo", checkQuery);
		it("[invalid/aNDShouldOnlyHaveOneKeyHasZero.json] aNDShouldOnlyHaveOneKeyHasZero", checkQuery);
		it("[invalid/cOLUMNSMustBeANonEmptyArrayNotBrackets.json] cOLUMNSMustBeANonEmptyArrayNotBrackets", checkQuery);
		it("[invalid/cOLUMNSMustBeANonEmptyArrayNotFilter.json] cOLUMNSMustBeANonEmptyArrayNotFilter", checkQuery);
		it("[invalid/cOLUMNSMustBeANonEmptyArrayNotNull.json] cOLUMNSMustBeANonEmptyArrayNotNull", checkQuery);
		it("[invalid/columnsWithEmptyStringField.json] columnsWithEmptyStringField", checkQuery);
		it("[invalid/countsEveryCharacterWhitespaceToo.json] countsEveryCharacterWhitespaceToo", checkQuery);
		it("[invalid/countsEveryCharacterWhitespaceTooKeys.json] countsEveryCharacterWhitespaceTooKeys", checkQuery);
		it("[invalid/doesnTConverToUppercase.json] doesnTConverToUppercase", checkQuery);
		it("[invalid/doubleUnderscoreIsInvalid.json] doubleUnderscoreIsInvalid", checkQuery);
		it("[invalid/emptyJSON.json] emptyJSON", checkQuery);
		it("[invalid/excessKeysInQuery.json] excessKeysInQuery", checkQuery);
		it("[invalid/gTShouldOnlyHaveOneKeyHasTwo.json] gTShouldOnlyHaveOneKeyHasTwo", checkQuery);
		it("[invalid/gTShouldOnlyHaveOneKeyHasZero.json] gTShouldOnlyHaveOneKeyHasZero", checkQuery);
		it("[invalid/invalidFilterKeySecond.json] invalidFilterKeySecond", checkQuery);
		it("[invalid/invalidFilterKeySectionsavg.json] invalidFilterKeySectionsavg", checkQuery);
		it("[invalid/invalidKeyInEQ.json] invalidKeyInEQ", checkQuery);
		it("[invalid/invalidKeyInIS.json] invalidKeyInIS", checkQuery);
		it("[invalid/invalidKeyNullInCOLUMNS.json] invalidKeyNullInCOLUMNS", checkQuery);
		it("[invalid/invalidKeySectionsdeptInCOLUMNS.json] invalidKeySectionsdeptInCOLUMNS", checkQuery);
		it("[invalid/invalidKeysInOPTIONS.json] invalidKeysInOPTIONS", checkQuery);
		it("[invalid/invalidORDERType.json] invalidORDERType", checkQuery);
		it("[invalid/invalidORDERTypeBrackets.json] invalidORDERTypeBrackets", checkQuery);
		it("[invalid/invalidORDERTypesquare.json] invalidORDERTypesquare", checkQuery);
		it("[invalid/invalidTypeOfCOLUMNKey.json] invalidTypeOfCOLUMNKey", checkQuery);
		it("[invalid/invalidTypeOfCOLUMNKeyFieldKey.json] invalidTypeOfCOLUMNKeyFieldKey", checkQuery);
		it("[invalid/invalidTypeOfCOLUMNKeySecond.json] invalidTypeOfCOLUMNKeySecond", checkQuery);
		it("[invalid/invalidValueTypeInGTShouldBeNumber.json] invalidValueTypeInGTShouldBeNumber", checkQuery);
		it("[invalid/invalidValueTypeInISShouldBeString.json] invalidValueTypeInISShouldBeString", checkQuery);
		it("[invalid/iSShouldOnlyHaveOneKeyHasTwo.json] iSShouldOnlyHaveOneKeyHasTwo", checkQuery);
		it("[invalid/iSShouldOnlyHaveOneKeyHasZero.json] iSShouldOnlyHaveOneKeyHasZero", checkQuery);
		it("[invalid/notCorrectObject.json] notCorrectObject", checkQuery);
		it("[invalid/nOTMustBeObject.json] nOTMustBeObject", checkQuery);
		it("[invalid/nOTMustBeObjectSquareBrackets.json] nOTMustBeObjectSquareBrackets", checkQuery);
		it("[invalid/nOTShouldOnlyHaveOneKeyHasTwo.json] nOTShouldOnlyHaveOneKeyHasTwo", checkQuery);
		it("[invalid/nOTShouldOnlyHaveOneKeyHasZero.json] nOTShouldOnlyHaveOneKeyHasZero", checkQuery);
		it("[invalid/nullQuery.json] nullQuery", checkQuery);
		it("[invalid/onlyThreeAsterisk.json] onlyThreeAsterisk", checkQuery);
		it("[invalid/oPTIONSMissingCOLUMNS.json] oPTIONSMissingCOLUMNS", checkQuery);
		it("[invalid/oRDERANDCOLUMNSKEYSWAPPED.json] oRDERANDCOLUMNSKEYSWAPPED", checkQuery);
		it("[invalid/oRDERCannotBeNull.json] oRDERCannotBeNull", checkQuery);
		it("[invalid/oRMustBeANonEmptyArray.json] oRMustBeANonEmptyArray", checkQuery);
		it("[invalid/oRMustBeANonEmptyArrayBrackets.json] oRMustBeANonEmptyArrayBrackets", checkQuery);
		it("[invalid/oRMustBeANonEmptyArrayEmptyString.json] oRMustBeANonEmptyArrayEmptyString", checkQuery);
		it("[invalid/oRMustBeANonEmptyArrayEmptyStringSecond.json] oRMustBeANonEmptyArrayEmptyStringSecond", checkQuery);
		it("[invalid/oRMustBeANonEmptyArraySecond.json] oRMustBeANonEmptyArraySecond", checkQuery);
		it("[invalid/oRShouldOnlyHaveOneKeyHasTwo.json] oRShouldOnlyHaveOneKeyHasTwo", checkQuery);
		it("[invalid/oRShouldOnlyHaveOneKeyHasZero.json] oRShouldOnlyHaveOneKeyHasZero", checkQuery);
		it("[invalid/referencedDatasetCannotBeEmptyString.json] referencedDatasetCannotBeEmptyString", checkQuery);
		it("[invalid/referencedDatasetSectionNotAddedYet.json] referencedDatasetSectionNotAddedYet", checkQuery);
		it("[invalid/wHEREMustBeObject.json] wHEREMustBeObject", checkQuery);
		it("[invalid/wHEREMustBeObjectNotNull.json] wHEREMustBeObjectNotNull", checkQuery);
		it("[invalid/wHEREMustBeObjectNotSquare.json] wHEREMustBeObjectNotSquare", checkQuery);
		it("[invalid/wHEREShouldOnlyHaveOneKeyHasTwo.json] wHEREShouldOnlyHaveOneKeyHasTwo", checkQuery);
		it("[invalid/notNothingIsEverything.json] notNothingIsEverything", checkQuery);
		it("[invalid/oPTIONSMustBeObject.json] oPTIONSMustBeObject", checkQuery);
		it("[invalid/gTMustBeObject.json] gTMustBeObject", checkQuery);
		it("[invalid/iSMustBeObject.json] iSMustBeObject", checkQuery);
		it("[invalid/invalidFilterFieldKeyTypeGTNoDuplicate.json] invalidFilterFieldKeyTypeGTNoDuplicate", checkQuery);
		it("[invalid/invalidFilterFieldKeyTypeISNoDuplicate.json] invalidFilterFieldKeyTypeISNoDuplicate", checkQuery);
		it("[invalid/invalidKeyColumnsFieldName.json] invalidKeyColumnsFieldName", checkQuery);
		it("[invalid/twoMiddleAsterisk.json] twoMiddleAsterisk", checkQuery);
		it("[invalid/columnsEmptyWhereValidEmpty.json] columnsEmptyWhereValidEmpty", checkQuery);
		it("[invalid/missingOptionsWhereValidEmpty.json] missingOptionsWhereValidEmpty", checkQuery);
		it("[invalid/oPTIONSMissingCOLUMNSWhereValidEmpty.json] oPTIONSMissingCOLUMNSWhereValidEmpty", checkQuery);
		it("[invalid/wHEREMustBeObjectNotSquareEmptyOptions.json] wHEREMustBeObjectNotSquareEmptyOptions", checkQuery);
		it(
			"[invalid/cOLUMNSMustBeANonEmptyArrayNotEmptyString.json] cOLUMNSMustBeANonEmptyArrayNotEmptyString",
			checkQuery
		);
		//it("[invalid/cannotTakeaExactlyFiveThousandsAndOne.json] cannotTakeaExactlyFiveThousandsAndOne", checkQuery); //
	});
});