From 1746f21bc3720585d2fe877db8d69aae301ff02c Mon Sep 17 00:00:00 2001 From: Rowan Goemans Date: Sun, 31 Dec 2017 02:03:08 +0100 Subject: -- Added many unit tests for the C parser. Almost complete now -- Refactored project structure to allow for more overview once we add more languages. -- Renamed a lot of types in the CParser to be more explicit. -- Made configuration injectable into the classes that need them. This allows to unit test configuration variables. -- Added 2 new config params that allows to customize what gets returned for a bool return type. -- Small changes to the logic to make it more concise. --- src/test/CTests/Operators.test.ts | 256 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 256 insertions(+) create mode 100644 src/test/CTests/Operators.test.ts (limited to 'src/test/CTests/Operators.test.ts') diff --git a/src/test/CTests/Operators.test.ts b/src/test/CTests/Operators.test.ts new file mode 100644 index 0000000..dd2aa5b --- /dev/null +++ b/src/test/CTests/Operators.test.ts @@ -0,0 +1,256 @@ +// +// Note: This example test is leveraging the Mocha test framework. +// Please refer to their documentation on https://mochajs.org/ for help. +// + +// The module 'assert' provides assertion methods from node +import * as assert from "assert"; + +// You can import and use all API from the 'vscode' module +// as well as import your extension to test it +import * as vscode from "vscode"; +import TestSetup from "./TestSetup"; + +// Defines a Mocha test suite to group tests of similar kind together +suite("Operators Tests", () => { + const testSetup: TestSetup = new TestSetup("void foo();"); + + // Tests + test("+ operator", () => { + const result = testSetup.SetLine("T operator +(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("- operator", () => { + const result = testSetup.SetLine("T operator- (const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("* operator", () => { + const result = testSetup.SetLine("T operator*(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("/ operator", () => { + const result = testSetup.SetLine("T operator/(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("% operator", () => { + const result = testSetup.SetLine("T operator%(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("^ operator", () => { + const result = testSetup.SetLine("T operator^(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("& operator", () => { + const result = testSetup.SetLine("T operator&(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("| operator", () => { + const result = testSetup.SetLine("T operator|(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("~ operator", () => { + const result = testSetup.SetLine("T operator~(const T& t);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param t \n * @return T \n */", result); + }); + + test("<< operator", () => { + const result = testSetup.SetLine("T operator<<(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test(">> operator", () => { + const result = testSetup.SetLine("T operator>>(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("! operator", () => { + const result = testSetup.SetLine("bool operator!(const T& t);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param t \n * @return true \n * @return false \n */", result); + }); + + test("&& operator", () => { + const result = testSetup.SetLine("bool operator&&(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n" + + " * @return false \n */", result); + }); + + test("|| operator", () => { + const result = testSetup.SetLine("bool operator||(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n" + + " * @return false \n */", result); + }); + + test("!= operator", () => { + const result = testSetup.SetLine("bool operator!=(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n" + + " * @return false \n */", result); + }); + + test("== operator", () => { + const result = testSetup.SetLine("bool operator==(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n" + + " * @return false \n */", result); + }); + + test("<= operator", () => { + const result = testSetup.SetLine("bool operator<=(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n" + + " * @return false \n */", result); + }); + + test(">= operator", () => { + const result = testSetup.SetLine("bool operator>=(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n" + + " * @return false \n */", result); + }); + + test("< operator", () => { + const result = testSetup.SetLine("bool operator<(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n" + + " * @return false \n */", result); + }); + + test("> operator", () => { + const result = testSetup.SetLine("bool operator>(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n" + + " * @return false \n */", result); + }); + + test("= operator", () => { + const result = testSetup.SetLine("T& operator=(const T& t);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result); + }); + + test("+= operator", () => { + const result = testSetup.SetLine("T& operator+=(const T& t);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result); + }); + + test("-= operator", () => { + const result = testSetup.SetLine("T& operator-=(const T& t);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result); + }); + + test("*= operator", () => { + const result = testSetup.SetLine("T& operator*=(const T& t);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result); + }); + + test("/= operator", () => { + const result = testSetup.SetLine("T& operator/=(const T& t);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result); + }); + + test("%= operator", () => { + const result = testSetup.SetLine("T& operator%=(const T& t);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result); + }); + + test("^= operator", () => { + const result = testSetup.SetLine("T& operator^=(const T& t);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result); + }); + + test("&= operator", () => { + const result = testSetup.SetLine("T& operator&=(const T& t);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result); + }); + + test("|= operator", () => { + const result = testSetup.SetLine("T& operator|=(const T& t);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result); + }); + + test(">>= operator", () => { + const result = testSetup.SetLine("T& operator>>=(const T& t);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result); + }); + + test("<<= operator", () => { + const result = testSetup.SetLine("T& operator<<=(const T& t);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result); + }); + + test("prefix ++ operator", () => { + const result = testSetup.SetLine("T& operator++();").GetResult(); + assert.equal("/**\n * @brief \n * \n * @return T& \n */", result); + }); + + test("prefix -- operator", () => { + const result = testSetup.SetLine("T& operator--();").GetResult(); + assert.equal("/**\n * @brief \n * \n * @return T& \n */", result); + }); + + test("postfix ++ operator", () => { + const result = testSetup.SetLine("T operator++(int);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @return T \n */", result); + }); + + test("postfix -- operator", () => { + const result = testSetup.SetLine("T operator--(int);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @return T \n */", result); + }); + + test(", operator", () => { + const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("->* operator", () => { + const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("-> operator", () => { + const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("[] operator", () => { + const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("() operator", () => { + const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("new operator", () => { + const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("new[] operator", () => { + const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("delete operator", () => { + const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("delete[] operator", () => { + const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("user literal operator", () => { + const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); + + test("conversion operator", () => { + const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult(); + assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result); + }); +}); -- cgit v1.2.3