From 67668448140e663e67bd889c6746e016cfee8259 Mon Sep 17 00:00:00 2001
From: Jason Turner <jason@emptycrate.com>
Date: Sun, 14 Jan 2024 16:28:17 -0700
Subject: [PATCH] Reformat with clang-format

---
 src/infiz/infiz.cpp              |  37 ++--
 src/libinfiz/Evaluator.cpp       | 291 +++++++++++++++----------------
 src/libinfiz/RationalNumber.cpp  |  68 ++++----
 src/libinfiz/RationalNumber.h    |  29 +--
 src/libinfiz/Stack.h             |  56 +++---
 src/libinfiz/StringTokenizer.cpp | 120 ++++++-------
 src/libinfiz/StringTokenizer.h   |  26 +--
 test/tests.cpp                   |  65 ++++---
 8 files changed, 337 insertions(+), 355 deletions(-)

diff --git a/src/infiz/infiz.cpp b/src/infiz/infiz.cpp
index d351224..5f14689 100644
--- a/src/infiz/infiz.cpp
+++ b/src/infiz/infiz.cpp
@@ -1,34 +1,33 @@
-//infiz.cpp
+// infiz.cpp
 
 #include "../libinfiz/Evaluator.hpp"
 #include "../libinfiz/RationalNumber.h"
 #include "../libinfiz/Stack.h"
 #include "../libinfiz/StringTokenizer.h"
 
-#include <iostream>
 #include <cstdlib>
+#include <iostream>
 
 const int max_line = 255;
 
-int main(int  /*argc*/, char *  /*args*/[]) {
-	
-	char input[max_line];  // NOLINT
+int main(int /*argc*/, char * /*args*/[])
+{
 
-	std::cin.getline(static_cast<char*>(input),max_line-1, '\n');
+  char input[max_line];// NOLINT
 
-	while (std::cin.good()) {
-		StringTokenizer tokenizer(static_cast<const char*>(input));
-		const RationalNumber answer = evaluateExpression(tokenizer);
-		std::cout << "answer: ";
+  std::cin.getline(static_cast<char *>(input), max_line - 1, '\n');
 
-                if (answer.getDenominator() == 1) {
-                  std::cout << answer.getNumerator() << '\n';
-                } else {
-                  std::cout << answer.getNumerator() << '/' << answer.getDenominator() << " (" << answer.getFloat()
-                            << ")" << '\n';
-                }
+  while (std::cin.good()) {
+    StringTokenizer tokenizer(static_cast<const char *>(input));
+    const RationalNumber answer = evaluateExpression(tokenizer);
+    std::cout << "answer: ";
 
-                std::cin.getline(static_cast<char *>(input),max_line-1, '\n');
-	}
-}
+    if (answer.getDenominator() == 1) {
+      std::cout << answer.getNumerator() << '\n';
+    } else {
+      std::cout << answer.getNumerator() << '/' << answer.getDenominator() << " (" << answer.getFloat() << ")" << '\n';
+    }
 
+    std::cin.getline(static_cast<char *>(input), max_line - 1, '\n');
+  }
+}
diff --git a/src/libinfiz/Evaluator.cpp b/src/libinfiz/Evaluator.cpp
index e57ea62..1c9f627 100644
--- a/src/libinfiz/Evaluator.cpp
+++ b/src/libinfiz/Evaluator.cpp
@@ -1,157 +1,156 @@
 
-#include <cstdlib>
 #include "Evaluator.hpp"
+#include <cstdlib>
 
 
-int precedence(Operators input) {
-	switch (input) {
-	case CLOSE_PAREN:
-		return 3;
-	case PLUS_SIGN:
-	case MINUS_SIGN:
-		return 1;
-	case MULTIPLY_SIGN:
-	case DIVIDE_SIGN:
-		return 2;
-	case OPEN_PAREN:
-		return 0;
-	}
-
-	return 0;
+int precedence(Operators input)
+{
+  switch (input) {
+  case CLOSE_PAREN:
+    return 3;
+  case PLUS_SIGN:
+  case MINUS_SIGN:
+    return 1;
+  case MULTIPLY_SIGN:
+  case DIVIDE_SIGN:
+    return 2;
+  case OPEN_PAREN:
+    return 0;
+  }
+
+  return 0;
 }
 
 
-void evaluateStacks(Stack<RationalNumber> &numbers, Stack<int> &operators) {
-	bool eatOpenParen = false;
-	bool cont = true;
-
-	if ( *operators.peek() == CLOSE_PAREN ) {
-		eatOpenParen = true;
-		operators.pop();
-	}
-
-	while ( (operators.peek() != NULL) && cont) { // NOLINT
-
-		switch( *operators.peek() ) {
-		case OPEN_PAREN:
-			if (eatOpenParen) {
-				operators.pop();
-				cont = false;
-			} else {
-				cont = false;
-			}
-
-			break;
-			
-		case PLUS_SIGN:{
-			operators.pop();
-			const RationalNumber operand2 = numbers.pop();
-			const RationalNumber operand1 = numbers.pop();
-			numbers.push(operand1 + operand2);
-			break;
-					   }
-
-		case MINUS_SIGN: {
-			operators.pop();
-			numbers.push(-numbers.pop());
-			break;
-						 }
-
-		case MULTIPLY_SIGN: {
-			operators.pop();
-			const RationalNumber operand2 = numbers.pop();
-			const RationalNumber operand1 = numbers.pop();
-			numbers.push(operand1 * operand2);
-			break;
-							}
-
-		case DIVIDE_SIGN: {
-			operators.pop();
-			const RationalNumber operand2 = numbers.pop();
-			const RationalNumber operand1 = numbers.pop();
-			numbers.push(operand1 / operand2);
-			break;
-						  }
-		}
-		
-	}
+void evaluateStacks(Stack<RationalNumber> &numbers, Stack<int> &operators)
+{
+  bool eatOpenParen = false;
+  bool cont = true;
+
+  if (*operators.peek() == CLOSE_PAREN) {
+    eatOpenParen = true;
+    operators.pop();
+  }
+
+  while ((operators.peek() != NULL) && cont) {// NOLINT
+
+    switch (*operators.peek()) {
+    case OPEN_PAREN:
+      if (eatOpenParen) {
+        operators.pop();
+        cont = false;
+      } else {
+        cont = false;
+      }
+
+      break;
+
+    case PLUS_SIGN: {
+      operators.pop();
+      const RationalNumber operand2 = numbers.pop();
+      const RationalNumber operand1 = numbers.pop();
+      numbers.push(operand1 + operand2);
+      break;
+    }
+
+    case MINUS_SIGN: {
+      operators.pop();
+      numbers.push(-numbers.pop());
+      break;
+    }
+
+    case MULTIPLY_SIGN: {
+      operators.pop();
+      const RationalNumber operand2 = numbers.pop();
+      const RationalNumber operand1 = numbers.pop();
+      numbers.push(operand1 * operand2);
+      break;
+    }
+
+    case DIVIDE_SIGN: {
+      operators.pop();
+      const RationalNumber operand2 = numbers.pop();
+      const RationalNumber operand1 = numbers.pop();
+      numbers.push(operand1 / operand2);
+      break;
+    }
+    }
+  }
 }
 
 
-
-
-RationalNumber evaluateExpression(StringTokenizer &tokenizer) {
-	Stack<int> operators;
-	Stack<RationalNumber> numbers;
-
-	while (tokenizer.hasMoreTokens()) {
-
-		std::string next = tokenizer.nextToken();
-
-		Operators value = PLUS_SIGN;
-
-		if (!next.empty()) {
-                  bool operation = false;
-                  switch(next[0]) {
-			case '+':
-				value = PLUS_SIGN;
-                                operation = true;
-				break;
-			case '/':
-				value = DIVIDE_SIGN;
-                                operation = true;
-				break;
-			case '-':
-				value = MINUS_SIGN;
-                                operation = true;
-				break;
-			case '*':
-				value = MULTIPLY_SIGN;
-                                operation = true;
-				break;
-			case ')':
-				value = CLOSE_PAREN;
-                                operation = true;
-				break;
-			case '(':
-				value = OPEN_PAREN;
-                                operation = true;
-				break;
-
-			default:
-                          operation = false;
-				numbers.push(RationalNumber(atoi(next.c_str()), 1)); // NOLINT
-				break;
-			}
-
-			if (operation) {
-				switch (value) {
-				case OPEN_PAREN:
-					operators.push(value);
-					break;
-				case CLOSE_PAREN:
-					operators.push(value);
-					evaluateStacks(numbers, operators);
-					break;
-				default:
-					if (operators.peek() != NULL // NOLINT
-						&& precedence(value) <= precedence(static_cast<Operators>(*operators.peek())) ) {
-						evaluateStacks(numbers, operators);
-					}
-					operators.push(value);
-					break;
-				}
-			}
-		}
-	}
-
-	if (operators.peek() != NULL) // NOLINT
-		evaluateStacks(numbers, operators);
-
-	if (numbers.peek() != NULL) { // NOLINT
-		return *numbers.peek(); 
-	} else {
-		return RationalNumber(0,0); // NOLINT
-	}
+RationalNumber evaluateExpression(StringTokenizer &tokenizer)
+{
+  Stack<int> operators;
+  Stack<RationalNumber> numbers;
+
+  while (tokenizer.hasMoreTokens()) {
+
+    std::string next = tokenizer.nextToken();
+
+    Operators value = PLUS_SIGN;
+
+    if (!next.empty()) {
+      bool operation = false;
+      switch (next[0]) {
+      case '+':
+        value = PLUS_SIGN;
+        operation = true;
+        break;
+      case '/':
+        value = DIVIDE_SIGN;
+        operation = true;
+        break;
+      case '-':
+        value = MINUS_SIGN;
+        operation = true;
+        break;
+      case '*':
+        value = MULTIPLY_SIGN;
+        operation = true;
+        break;
+      case ')':
+        value = CLOSE_PAREN;
+        operation = true;
+        break;
+      case '(':
+        value = OPEN_PAREN;
+        operation = true;
+        break;
+
+      default:
+        operation = false;
+        numbers.push(RationalNumber(atoi(next.c_str()), 1));// NOLINT
+        break;
+      }
+
+      if (operation) {
+        switch (value) {
+        case OPEN_PAREN:
+          operators.push(value);
+          break;
+        case CLOSE_PAREN:
+          operators.push(value);
+          evaluateStacks(numbers, operators);
+          break;
+        default:
+          if (operators.peek() != NULL// NOLINT
+              && precedence(value) <= precedence(static_cast<Operators>(*operators.peek()))) {
+            evaluateStacks(numbers, operators);
+          }
+          operators.push(value);
+          break;
+        }
+      }
+    }
+  }
+
+  if (operators.peek() != NULL)// NOLINT
+    evaluateStacks(numbers, operators);
+
+  if (numbers.peek() != NULL) {// NOLINT
+    return *numbers.peek();
+  } else {
+    return RationalNumber(0, 0);// NOLINT
+  }
 }
-
diff --git a/src/libinfiz/RationalNumber.cpp b/src/libinfiz/RationalNumber.cpp
index 09ab5e1..00ef4e1 100644
--- a/src/libinfiz/RationalNumber.cpp
+++ b/src/libinfiz/RationalNumber.cpp
@@ -1,55 +1,51 @@
-//RationalNumber.h
+// RationalNumber.h
 
 #include "RationalNumber.h"
 
-RationalNumber::RationalNumber(int num, int den) // NOLINT
-	: numerator(num), denominator(den)
-{
-}
+RationalNumber::RationalNumber(int num, int den)// NOLINT
+  : numerator(num), denominator(den)
+{}
 
-RationalNumber RationalNumber::operator/(const RationalNumber &rhs) const {
-	return RationalNumber( // NOLINT
-		numerator * rhs.getDenominator(),
-		denominator * rhs.getNumerator()
-		);
+RationalNumber RationalNumber::operator/(const RationalNumber &rhs) const
+{
+  return RationalNumber(// NOLINT
+    numerator * rhs.getDenominator(),
+    denominator * rhs.getNumerator());
 }
 
-RationalNumber RationalNumber::operator*(const RationalNumber &rhs) const {
-	return RationalNumber( // NOLINT
-		numerator * rhs.getNumerator(),
-		denominator * rhs.getDenominator());
+RationalNumber RationalNumber::operator*(const RationalNumber &rhs) const
+{
+  return RationalNumber(// NOLINT
+    numerator * rhs.getNumerator(),
+    denominator * rhs.getDenominator());
 }
 
-RationalNumber RationalNumber::operator+(const RationalNumber &rhs) const {
-	const int denom = denominator * rhs.getDenominator();
-	const int new_numerator = this->numerator * rhs.getDenominator();
-	const int numer = new_numerator + (rhs.getNumerator() * denominator);
+RationalNumber RationalNumber::operator+(const RationalNumber &rhs) const
+{
+  const int denom = denominator * rhs.getDenominator();
+  const int new_numerator = this->numerator * rhs.getDenominator();
+  const int numer = new_numerator + (rhs.getNumerator() * denominator);
 
-	return RationalNumber(numer, denom); // NOLINT
+  return RationalNumber(numer, denom);// NOLINT
 }
 
-RationalNumber RationalNumber::operator-(const RationalNumber &rhs) const {
-	const int denom = denominator * rhs.getDenominator();
-	
-	const int new_numerator = this->numerator * rhs.getDenominator();
-	const int numer = new_numerator - (rhs.getNumerator() * denominator);
+RationalNumber RationalNumber::operator-(const RationalNumber &rhs) const
+{
+  const int denom = denominator * rhs.getDenominator();
 
-	return RationalNumber(numer, denom); // NOLINT
-}
+  const int new_numerator = this->numerator * rhs.getDenominator();
+  const int numer = new_numerator - (rhs.getNumerator() * denominator);
 
-int RationalNumber::getDenominator() const {
-	return denominator;
+  return RationalNumber(numer, denom);// NOLINT
 }
 
-RationalNumber RationalNumber::operator-() const {
-	return RationalNumber(numerator * -1, denominator); // NOLINT
-}
+int RationalNumber::getDenominator() const { return denominator; }
 
-int RationalNumber::getNumerator() const {
-	return numerator;
+RationalNumber RationalNumber::operator-() const
+{
+  return RationalNumber(numerator * -1, denominator);// NOLINT
 }
 
-float RationalNumber::getFloat() const {
-	return ( (static_cast<float>(numerator)) / (static_cast<float>(denominator)) );
-}
+int RationalNumber::getNumerator() const { return numerator; }
 
+float RationalNumber::getFloat() const { return ((static_cast<float>(numerator)) / (static_cast<float>(denominator))); }
diff --git a/src/libinfiz/RationalNumber.h b/src/libinfiz/RationalNumber.h
index c23e9e9..93dbf61 100644
--- a/src/libinfiz/RationalNumber.h
+++ b/src/libinfiz/RationalNumber.h
@@ -1,30 +1,31 @@
 #ifndef INFIZ_RATIONAL_NUMBER_H
 #define INFIZ_RATIONAL_NUMBER_H
 
-//RationalNumber.h
+// RationalNumber.h
 
 /**
  * A Class that stores the numerator and denominator
  * of a rational number.
  */
 
-class RationalNumber {
+class RationalNumber
+{
 public:
-	RationalNumber(int num, int den);
-	RationalNumber operator/(const RationalNumber &rhs) const;
-	RationalNumber operator*(const RationalNumber &rhs) const;
-	RationalNumber operator+(const RationalNumber &rhs) const;
-	RationalNumber operator-(const RationalNumber &rhs) const;
-	RationalNumber operator-() const;
+  RationalNumber(int num, int den);
+  RationalNumber operator/(const RationalNumber &rhs) const;
+  RationalNumber operator*(const RationalNumber &rhs) const;
+  RationalNumber operator+(const RationalNumber &rhs) const;
+  RationalNumber operator-(const RationalNumber &rhs) const;
+  RationalNumber operator-() const;
 
-	int getNumerator() const;
-	int getDenominator() const;
+  int getNumerator() const;
+  int getDenominator() const;
+
+  float getFloat() const;
 
-	float getFloat() const;
-	
 private:
-	int numerator;
-	int denominator;
+  int numerator;
+  int denominator;
 };
 
 #endif
\ No newline at end of file
diff --git a/src/libinfiz/Stack.h b/src/libinfiz/Stack.h
index d44ad6f..a14ce76 100644
--- a/src/libinfiz/Stack.h
+++ b/src/libinfiz/Stack.h
@@ -3,42 +3,42 @@
 
 // Stack.h
 
-#include <vector>
 #include <cassert>
 #include <cstddef>
+#include <vector>
 
 /**
-* A Class that allows allows void * to be
-* pushed onto an popped off of a stack.
-*/
+ * A Class that allows allows void * to be
+ * pushed onto an popped off of a stack.
+ */
 
-template<typename Contained>
-class Stack
+template<typename Contained> class Stack
 {
 public:
-	Stack(){}
-	
-	
-	Contained pop() {
-		assert(!data.empty());
-		Contained toReturn = data.back();
-		data.pop_back();
-		return toReturn;
-	}
-		
-	void push(const Contained &newElem) {
-		data.push_back(newElem);
-	}
-	
-	const Contained * peek() const {
-		if (data.empty()) {
-			return NULL;
-		} else {
-			return &data.back();
-		}
-	}
+  Stack() {}
+
+
+  Contained pop()
+  {
+    assert(!data.empty());
+    Contained toReturn = data.back();
+    data.pop_back();
+    return toReturn;
+  }
+
+  void push(const Contained &newElem) { data.push_back(newElem); }
+
+  const Contained *peek() const
+  {
+    if (data.empty()) {
+      return NULL;
+    } else {
+      return &data.back();
+    }
+  }
+
 private:
-	std::vector<Contained> data;
+  std::vector<Contained> data;
 };
 
 #endif
\ No newline at end of file
diff --git a/src/libinfiz/StringTokenizer.cpp b/src/libinfiz/StringTokenizer.cpp
index e8676c2..1536b39 100644
--- a/src/libinfiz/StringTokenizer.cpp
+++ b/src/libinfiz/StringTokenizer.cpp
@@ -3,88 +3,76 @@
 #include "StringTokenizer.h"
 #include <string>
 
-StringTokenizer::StringTokenizer(const std::string &n_string) // NOLINT
+StringTokenizer::StringTokenizer(const std::string &n_string)// NOLINT
   : string(n_string), currentOffset(0), moreTokens(true)
+{}
+
+
+std::string StringTokenizer::nextToken()
 {
-}
+  while (currentOffset < string.size() && isWhiteSpace(string[currentOffset])) { ++currentOffset; }
 
+  const size_type endOfToken = findTokenEnd(currentOffset, string);
 
-std::string StringTokenizer::nextToken() 
-{	
-	while (currentOffset<string.size() 
-		&& isWhiteSpace(string[currentOffset])) {
-		++currentOffset;
-	}
-	
-	const size_type endOfToken = findTokenEnd(currentOffset, string);
-	
-	std::string toReturn = string.substr(currentOffset, endOfToken-currentOffset);
-	currentOffset = endOfToken;
-	
-	moreTokens = currentOffset < string.size();
-	
-	return toReturn;
-}
+  std::string toReturn = string.substr(currentOffset, endOfToken - currentOffset);
+  currentOffset = endOfToken;
 
-bool StringTokenizer::hasMoreTokens() const {
-	return moreTokens;
-}
+  moreTokens = currentOffset < string.size();
 
-StringTokenizer::size_type StringTokenizer::findTokenEnd(size_type start, const std::string& string) {
-	if (string.empty()) {
-		return start;
-	}
-
-	if (isNumber(string[start])) {
-		while (start < string.size() && isNumber(string[start])) {
-			++start;
-		}
-	} else if ( isOperator(string[start]) )  {
-		++start;
-	}
-	
-	
-	return start;
+  return toReturn;
 }
 
+bool StringTokenizer::hasMoreTokens() const { return moreTokens; }
+
+StringTokenizer::size_type StringTokenizer::findTokenEnd(size_type start, const std::string &string)
+{
+  if (string.empty()) { return start; }
+
+  if (isNumber(string[start])) {
+    while (start < string.size() && isNumber(string[start])) { ++start; }
+  } else if (isOperator(string[start])) {
+    ++start;
+  }
 
 
-bool StringTokenizer::isOperator(char input) {
-	switch (input) {
-	case '+':
-	case '-':
-	case '/':
-	case '*':
-	case '(':
-	case ')':
-		return true;
-	default:
-		return false;
-	}
+  return start;
 }
 
 
-bool StringTokenizer::isNumber(char input) {
-	switch (input) {
-	case '1':
-	case '2':
-	case '3':
-	case '4':
-	case '5':
-	case '6':
-	case '7':
-	case '8':
-	case '9':
-	case '0':
-		return true;
-	default:
-		return false;
-	}
+bool StringTokenizer::isOperator(char input)
+{
+  switch (input) {
+  case '+':
+  case '-':
+  case '/':
+  case '*':
+  case '(':
+  case ')':
+    return true;
+  default:
+    return false;
+  }
 }
 
 
-bool StringTokenizer::isWhiteSpace(char input) {
-	return !isNumber(input) && !isOperator(input);
+bool StringTokenizer::isNumber(char input)
+{
+  switch (input) {
+  case '1':
+  case '2':
+  case '3':
+  case '4':
+  case '5':
+  case '6':
+  case '7':
+  case '8':
+  case '9':
+  case '0':
+    return true;
+  default:
+    return false;
+  }
 }
 
 
+bool StringTokenizer::isWhiteSpace(char input) { return !isNumber(input) && !isOperator(input); }
diff --git a/src/libinfiz/StringTokenizer.h b/src/libinfiz/StringTokenizer.h
index ce6a1fb..5f57b3e 100644
--- a/src/libinfiz/StringTokenizer.h
+++ b/src/libinfiz/StringTokenizer.h
@@ -13,23 +13,23 @@
 class StringTokenizer
 {
 public:
-	typedef std::string::size_type size_type;
+  typedef std::string::size_type size_type;
 
-	explicit StringTokenizer(const std::string &n_string);
-	
-	bool hasMoreTokens() const;
+  explicit StringTokenizer(const std::string &n_string);
 
-	std::string nextToken();
+  bool hasMoreTokens() const;
+
+  std::string nextToken();
 
 private:
-	std::string string;
-	size_type currentOffset;
-	bool moreTokens;
-
-	static bool isNumber(char input);
-	static bool isOperator(char input);
-	static bool isWhiteSpace(char input);
-	static size_type findTokenEnd(size_type start, const std::string &);
+  std::string string;
+  size_type currentOffset;
+  bool moreTokens;
+
+  static bool isNumber(char input);
+  static bool isOperator(char input);
+  static bool isWhiteSpace(char input);
+  static size_type findTokenEnd(size_type start, const std::string &);
 };
 
 #endif
\ No newline at end of file
diff --git a/test/tests.cpp b/test/tests.cpp
index 725bf2e..018bed7 100644
--- a/test/tests.cpp
+++ b/test/tests.cpp
@@ -10,42 +10,41 @@
 
 void run_test(const std::string &input, RationalNumber expected, bool &success)
 {
-	StringTokenizer tokenizer(input);
-	const RationalNumber result = evaluateExpression(tokenizer);
+  StringTokenizer tokenizer(input);
+  const RationalNumber result = evaluateExpression(tokenizer);
 
 
-	if (result.getDenominator() != expected.getDenominator() ||
-		result.getNumerator() != expected.getNumerator()) {
-		success = false;
-		std::cout << "FAIL: ";
-	} else {
-		std::cout << "PASS: ";
-	}
+  if (result.getDenominator() != expected.getDenominator() || result.getNumerator() != expected.getNumerator()) {
+    success = false;
+    std::cout << "FAIL: ";
+  } else {
+    std::cout << "PASS: ";
+  }
 
-	std::cout << "input: " << input 
-		<< " expected: "  << expected.getNumerator() << '/' << expected.getDenominator() 
-		<< " got: " << result.getNumerator() << '/' << result.getDenominator() << '\n';
+  std::cout << "input: " << input << " expected: " << expected.getNumerator() << '/' << expected.getDenominator()
+            << " got: " << result.getNumerator() << '/' << result.getDenominator() << '\n';
 }
 
-int main() {
-	bool all_passed = true;
-
-	run_test("(3 + 2)", RationalNumber(5, 1), all_passed); // NOLINT
-	run_test("(3 / 2)", RationalNumber(3, 2), all_passed);// NOLINT
-	run_test("(4 / 2)", RationalNumber(4, 2), all_passed);// NOLINT
-	run_test("(4 / 2) * 5", RationalNumber(20, 2), all_passed);// NOLINT
-	run_test("(1 / 2) / 3", RationalNumber(1, 6), all_passed);// NOLINT
-	run_test("((1 + 2) + 3) + 4", RationalNumber(10, 1), all_passed);// NOLINT
-
-	run_test("1 / 2 / 3", RationalNumber(1, 6), all_passed);// NOLINT
-	run_test("1 + 2 + 3 + 4", RationalNumber(10, 1), all_passed);// NOLINT
-	run_test("1+2+3+4", RationalNumber(10, 1), all_passed);// NOLINT
-	run_test("10/2*3", RationalNumber(30, 2), all_passed);// NOLINT
-	run_test("10/(2*3)", RationalNumber(10, 6), all_passed);// NOLINT
-
-	if (all_passed) {
-		return EXIT_SUCCESS;
-	} else {
-		return EXIT_FAILURE;
-	}
+int main()
+{
+  bool all_passed = true;
+
+  run_test("(3 + 2)", RationalNumber(5, 1), all_passed);// NOLINT
+  run_test("(3 / 2)", RationalNumber(3, 2), all_passed);// NOLINT
+  run_test("(4 / 2)", RationalNumber(4, 2), all_passed);// NOLINT
+  run_test("(4 / 2) * 5", RationalNumber(20, 2), all_passed);// NOLINT
+  run_test("(1 / 2) / 3", RationalNumber(1, 6), all_passed);// NOLINT
+  run_test("((1 + 2) + 3) + 4", RationalNumber(10, 1), all_passed);// NOLINT
+
+  run_test("1 / 2 / 3", RationalNumber(1, 6), all_passed);// NOLINT
+  run_test("1 + 2 + 3 + 4", RationalNumber(10, 1), all_passed);// NOLINT
+  run_test("1+2+3+4", RationalNumber(10, 1), all_passed);// NOLINT
+  run_test("10/2*3", RationalNumber(30, 2), all_passed);// NOLINT
+  run_test("10/(2*3)", RationalNumber(10, 6), all_passed);// NOLINT
+
+  if (all_passed) {
+    return EXIT_SUCCESS;
+  } else {
+    return EXIT_FAILURE;
+  }
 }
\ No newline at end of file