Line data    Source code

       1           1 : /**
       2             : 
       3             : @file CalculatorApp.java
       4             : @brief This file serves as the main application file for the Calculator App.
       5             : @details This file contains the entry point of the application, which is the main method. It initializes the necessary components and executes the Calculator App.
       6             : */
       7             : /**
       8             : 
       9             : @package com.ucoruh.calculator
      10             : @brief The com.ucoruh.calculator package contains all the classes and files related to the Calculator App.
      11             : */
      12             : package com.ucoruh.calculator;
      13             : 
      14             : import org.slf4j.LoggerFactory;
      15             : 
      16             : import ch.qos.logback.classic.Logger;
      17             : 
      18             : /**
      19             :  *
      20             :  * @class CalculatorApp
      21             :  * @brief This class represents the main application class for the Calculator
      22             :  *        App.
      23             :  * @details The CalculatorApp class provides the entry point for the Calculator
      24             :  *          App. It parses three command-line arguments (operand, operator,
      25             :  *          operand), computes the result with {@link Calculator} and prints
      26             :  *          it. It never reads from standard input, so it is safe to run from
      27             :  *          a non-interactive script and to unit test directly.
      28             :  * @author ugur.coruh
      29             :  */
      30           1 : public class CalculatorApp {
      31             :   /**
      32             :    * @brief Logger for the CalculatorApp class.
      33             :    */
      34           1 :   private static final Logger logger = (Logger) LoggerFactory.getLogger(CalculatorApp.class);
      35             : 
      36             :   /**
      37             :    * @brief Usage message shown when the arguments do not describe a single
      38             :    *        binary operation.
      39             :    */
      40             :   static final String USAGE = "Usage: CalculatorApp <number> <+|-|*|/> <number>";
      41             : 
      42           0 :   private CalculatorApp() {
      43             :     // Utility/entry-point class: not meant to be instantiated.
      44             :   }
      45             : 
      46             :   /**
      47             :    * @brief The main entry point of the Calculator App.
      48             :    *
      49             :    * @details Delegates all the work to {@link #run(String[])} and prints its
      50             :    *          result. Kept deliberately thin so that the parsing/calculation
      51             :    *          logic in `run` can be unit tested without touching the console.
      52             :    *
      53             :    * @param args The command-line arguments passed to the application:
      54             :    *             `<number> <operator> <number>`.
      55             :    */
      56           1 :   public static void main(String[] args) {
      57             :     System.out.println(run(args));
      58             :   }
      59             : 
      60             :   /**
      61             :    * @brief Parses `args` as `<number> <operator> <number>` and computes the
      62             :    *        result.
      63             :    *
      64             :    * @details This is the testable core of the application: it performs no
      65             :    *          I/O (it neither reads from `System.in` nor writes to
      66             :    *          `System.out`) and never blocks, so it can be called directly
      67             :    *          from tests and from scripts alike. Recognized operators are
      68             :    *          `+`, `-`, `*` and `/`. Invalid input (wrong argument count,
      69             :    *          non-numeric operand, unknown operator, division by zero) is
      70             :    *          reported as a descriptive `"Error: ..."` string instead of an
      71             :    *          uncaught exception, so the process always exits cleanly with a
      72             :    *          printable message.
      73             :    *
      74             :    * @param args The command-line arguments.
      75             :    * @return A human-readable result or error message.
      76             :    */
      77             :   static String run(String[] args) {
      78             :     if (args == null || args.length != 3) {
      79             :       logger.warn("Expected 3 arguments, got {}", args == null ? 0 : args.length);
      80             :       return USAGE;
      81             :     }
      82             : 
      83             :     final int left;
      84             :     final int right;
      85             : 
      86             :     try {
      87             :       left = Integer.parseInt(args[0]);
      88             :       right = Integer.parseInt(args[2]);
      89             :     } catch (NumberFormatException e) {
      90             :       logger.error("Invalid operand: {}", e.toString());
      91             :       return "Error: operands must be integers. " + USAGE;
      92             :     }
      93             : 
      94             :     String operator = args[1];
      95             :     Calculator calculator = new Calculator();
      96             : 
      97             :     switch (operator) {
      98             :       case "+":
      99             :         return String.valueOf(calculator.add(left, right));
     100             : 
     101             :       case "-":
     102             :         return String.valueOf(calculator.subtract(left, right));
     103             : 
     104             :       case "*":
     105             :         return String.valueOf(calculator.multiply(left, right));
     106             : 
     107             :       case "/":
     108             :         try {
     109             :           return String.valueOf(calculator.divide(left, right));
     110             :         } catch (ArithmeticException e) {
     111             :           logger.error("Division by zero requested");
     112             :           return "Error: division by zero";
     113             :         }
     114             : 
     115             :       default:
     116             :         logger.warn("Unknown operator: {}", operator);
     117             :         return "Error: unknown operator '" + operator + "'. " + USAGE;
     118             :     }
     119             :   }
     120             : }