/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 **/

#include <cstdint>
#include <limits>
#include <memory>
#include <utility>
#include <vector>

#include "types/DateOperatorOverloads.hpp"
#include "types/DatetimeLit.hpp"
#include "types/IntervalLit.hpp"
#include "types/Type.hpp"
#include "types/TypeFactory.hpp"
#include "types/TypeID.hpp"
#include "types/TypedValue.hpp"
#include "types/operations/Operation.pb.h"
#include "types/operations/binary_operations/BinaryOperation.hpp"
#include "types/operations/binary_operations/BinaryOperationFactory.hpp"
#include "types/operations/binary_operations/BinaryOperationID.hpp"
#include "utility/Macros.hpp"

#include "glog/logging.h"
#include "gtest/gtest.h"

using std::int64_t;
using std::numeric_limits;
using std::pair;
using std::unique_ptr;
using std::vector;

namespace quickstep {

class BinaryOperationTest : public ::testing::Test {
 protected:
  template <typename NumericType>
  static NumericType GetTypedValueAsNumeric(const TypedValue &value) {
    switch (value.getTypeID()) {
      case kInt:
        return value.getLiteral<int>();
      case kLong:
        return value.getLiteral<std::int64_t>();
      case kFloat:
        return value.getLiteral<float>();
      case kDouble:
        return value.getLiteral<double>();
      default:
        FATAL_ERROR("TypedValue does not appear to be numeric.");
    }
  }

  static bool TypedValueIsZero(const TypedValue &value) {
    switch (value.getTypeID()) {
      case kInt:
        return value.getLiteral<int>() == 0;
      case kLong:
        return value.getLiteral<std::int64_t>() == 0;
      case kFloat:
        return value.getLiteral<float>() == 0.0f;
      case kDouble:
        return value.getLiteral<double>() == 0.0;
      default:
        FATAL_ERROR("TypedValue does not appear to be numeric.");
    }
  }

  virtual void SetUp() {
    int_null_.reset(new TypedValue(kInt));
    int_zero_.reset(new TypedValue(0));
    int_positive_.reset(new TypedValue(12345));
    int_negative_.reset(new TypedValue(- int_positive_->getLiteral<int>()));
    int_max_.reset(new TypedValue(numeric_limits<int>::max()));
    int_min_.reset(new TypedValue(numeric_limits<int>::min()));

    numeric_typed_values_.emplace_back(int_null_.get(),
                                       &TypeFactory::GetType(kInt, true));
    numeric_typed_values_.emplace_back(int_zero_.get(),
                                       &TypeFactory::GetType(kInt, false));
    numeric_typed_values_.emplace_back(int_positive_.get(),
                                       &TypeFactory::GetType(kInt, false));
    numeric_typed_values_.emplace_back(int_negative_.get(),
                                       &TypeFactory::GetType(kInt, false));
    numeric_typed_values_.emplace_back(int_max_.get(),
                                       &TypeFactory::GetType(kInt, false));
    numeric_typed_values_.emplace_back(int_min_.get(),
                                       &TypeFactory::GetType(kInt, false));

    long_null_.reset(new TypedValue(kLong));
    long_zero_.reset(new TypedValue(static_cast<int64_t>(0)));
    long_positive_.reset(new TypedValue(static_cast<int64_t>(12345)));
    long_negative_.reset(new TypedValue(- long_positive_->getLiteral<int64_t>()));
    long_max_.reset(new TypedValue(numeric_limits<int64_t>::max()));
    long_min_.reset(new TypedValue(numeric_limits<int64_t>::min()));

    numeric_typed_values_.emplace_back(long_null_.get(),
                                       &TypeFactory::GetType(kLong, true));
    numeric_typed_values_.emplace_back(long_zero_.get(),
                                       &TypeFactory::GetType(kLong, false));
    numeric_typed_values_.emplace_back(long_positive_.get(),
                                       &TypeFactory::GetType(kLong, false));
    numeric_typed_values_.emplace_back(long_negative_.get(),
                                       &TypeFactory::GetType(kLong, false));
    numeric_typed_values_.emplace_back(long_max_.get(),
                                       &TypeFactory::GetType(kLong, false));
    numeric_typed_values_.emplace_back(long_min_.get(),
                                       &TypeFactory::GetType(kLong, false));

    float_null_.reset(new TypedValue(kFloat));
    float_zero_.reset(new TypedValue(static_cast<float>(0.0)));
    float_positive_.reset(new TypedValue(static_cast<float>(123.45)));
    float_negative_.reset(new TypedValue(- float_positive_->getLiteral<float>()));
    float_max_.reset(new TypedValue(numeric_limits<float>::max()));
    float_min_.reset(new TypedValue(numeric_limits<float>::min()));

    numeric_typed_values_.emplace_back(float_null_.get(),
                                       &TypeFactory::GetType(kFloat, true));
    numeric_typed_values_.emplace_back(float_zero_.get(),
                                       &TypeFactory::GetType(kFloat, false));
    numeric_typed_values_.emplace_back(float_positive_.get(),
                                       &TypeFactory::GetType(kFloat, false));
    numeric_typed_values_.emplace_back(float_negative_.get(),
                                       &TypeFactory::GetType(kFloat, false));
    numeric_typed_values_.emplace_back(float_max_.get(),
                                       &TypeFactory::GetType(kFloat, false));
    numeric_typed_values_.emplace_back(float_min_.get(),
                                       &TypeFactory::GetType(kFloat, false));

    double_null_.reset(new TypedValue(kDouble));
    double_zero_.reset(new TypedValue(static_cast<double>(0)));
    double_positive_.reset(new TypedValue(static_cast<double>(123.45)));
    double_negative_.reset(new TypedValue(- double_positive_->getLiteral<double>()));
    double_max_.reset(new TypedValue(numeric_limits<double>::max()));
    double_min_.reset(new TypedValue(numeric_limits<double>::min()));

    numeric_typed_values_.emplace_back(double_null_.get(),
                                       &TypeFactory::GetType(kDouble, true));
    numeric_typed_values_.emplace_back(double_zero_.get(),
                                       &TypeFactory::GetType(kDouble, false));
    numeric_typed_values_.emplace_back(double_positive_.get(),
                                       &TypeFactory::GetType(kDouble, false));
    numeric_typed_values_.emplace_back(double_negative_.get(),
                                       &TypeFactory::GetType(kDouble, false));
    numeric_typed_values_.emplace_back(double_max_.get(),
                                       &TypeFactory::GetType(kDouble, false));
    numeric_typed_values_.emplace_back(double_min_.get(),
                                       &TypeFactory::GetType(kDouble, false));

    datetime_null_.reset(new TypedValue(kDatetime));
    DatetimeLit datetime;
    datetime.ticks = 0;
    datetime_zero_.reset(new TypedValue(datetime));
    datetime.ticks = 12345678;
    datetime_positive_.reset(new TypedValue(datetime));
    datetime.ticks = -87654321;
    datetime_negative_.reset(new TypedValue(datetime));
    datetime.ticks = numeric_limits<int64_t>::max();
    datetime_max_.reset(new TypedValue(datetime));
    datetime.ticks = numeric_limits<int64_t>::min();
    datetime_min_.reset(new TypedValue(datetime));

    datetime_typed_values_.emplace_back(datetime_null_.get(),
                                        &TypeFactory::GetType(kDatetime, true));
    datetime_typed_values_.emplace_back(datetime_zero_.get(),
                                        &TypeFactory::GetType(kDatetime, false));
    datetime_typed_values_.emplace_back(datetime_positive_.get(),
                                        &TypeFactory::GetType(kDatetime, false));
    datetime_typed_values_.emplace_back(datetime_negative_.get(),
                                        &TypeFactory::GetType(kDatetime, false));
    datetime_typed_values_.emplace_back(datetime_max_.get(),
                                        &TypeFactory::GetType(kDatetime, false));
    datetime_typed_values_.emplace_back(datetime_min_.get(),
                                        &TypeFactory::GetType(kDatetime, false));

    datetime_interval_null_.reset(new TypedValue(kDatetimeInterval));
    DatetimeIntervalLit datetime_interval;
    datetime_interval.interval_ticks = 0;
    datetime_interval_zero_.reset(new TypedValue(datetime_interval));
    datetime_interval.interval_ticks = 87654321;
    datetime_interval_positive_.reset(new TypedValue(datetime_interval));
    datetime_interval.interval_ticks = -12345678;
    datetime_interval_negative_.reset(new TypedValue(datetime_interval));

    datetime_interval_typed_values_.emplace_back(datetime_interval_null_.get(),
                                                 &TypeFactory::GetType(kDatetimeInterval, true));
    datetime_interval_typed_values_.emplace_back(datetime_interval_zero_.get(),
                                                 &TypeFactory::GetType(kDatetimeInterval, false));
    datetime_interval_typed_values_.emplace_back(datetime_interval_positive_.get(),
                                                 &TypeFactory::GetType(kDatetimeInterval, false));
    datetime_interval_typed_values_.emplace_back(datetime_interval_negative_.get(),
                                                 &TypeFactory::GetType(kDatetimeInterval, false));

    year_month_interval_null_.reset(new TypedValue(kYearMonthInterval));
    YearMonthIntervalLit year_month_interval;
    year_month_interval.months = 0;
    year_month_interval_zero_.reset(new TypedValue(year_month_interval));
    year_month_interval.months = 12;  // 1 year forward.
    year_month_interval_positive_.reset(new TypedValue(year_month_interval));
    year_month_interval.months = -3;  // 3 months backward.
    year_month_interval_negative_.reset(new TypedValue(year_month_interval));

    year_month_interval_typed_values_.emplace_back(year_month_interval_null_.get(),
                                                   &TypeFactory::GetType(kYearMonthInterval, true));
    year_month_interval_typed_values_.emplace_back(year_month_interval_zero_.get(),
                                                   &TypeFactory::GetType(kYearMonthInterval, false));
    year_month_interval_typed_values_.emplace_back(year_month_interval_positive_.get(),
                                                   &TypeFactory::GetType(kYearMonthInterval, false));
    year_month_interval_typed_values_.emplace_back(year_month_interval_negative_.get(),
                                                   &TypeFactory::GetType(kYearMonthInterval, false));
  }

  void checkNumericBinaryOperation(const BinaryOperation &operation) {
    for (const pair<const TypedValue*, const Type*> &left_item : numeric_typed_values_) {
      for (const pair<const TypedValue*, const Type*> &right_item : numeric_typed_values_) {
        if ((operation.getBinaryOperationID() == BinaryOperationID::kDivide ||
             operation.getBinaryOperationID() == BinaryOperationID::kModulo) &&
            !right_item.first->isNull() &&
            TypedValueIsZero(*right_item.first)) {
          // Avoid Divide-by-zero errors.
          continue;
        }

        checkNumericBinaryOperationChecked(operation,
                                           *left_item.first,
                                           *left_item.second,
                                           *right_item.first,
                                           *right_item.second);
        checkNumericBinaryOperatorUnchecked(operation,
                                            *left_item.first,
                                            *left_item.second,
                                            *right_item.first,
                                            *right_item.second);
      }
    }
  }

  void checkDateAddBinaryOperators() {
    // Add DatetimeLit and DatetimeIntervalLit.
    DatetimeLit datetime_1995_08_01;
    datetime_1995_08_01.ticks = 807235200020000;  // 01 Aug 1995 00:00:00 GMT.

    DatetimeIntervalLit interval_20_days;
    interval_20_days.interval_ticks = 1728000000000;

    DatetimeLit datetime_1995_08_21;
    datetime_1995_08_21.ticks = 808963200020000;  // 21 Aug 1995 00:00:00 GMT.

    EXPECT_EQ(datetime_1995_08_21, datetime_1995_08_01 + interval_20_days);
    EXPECT_EQ(datetime_1995_08_21, interval_20_days + datetime_1995_08_01);

    // Add DatetimeIntervalLit and DatetimeIntervalLit.
    DatetimeIntervalLit interval_40_days;
    interval_40_days.interval_ticks = 3456000000000;
    EXPECT_EQ(interval_40_days, interval_20_days + interval_20_days);

    // Add DatetimeLit and YearMonthIntervalLit.
    DatetimeLit datetime_1997_01_01;
    datetime_1997_01_01.ticks = 852076800000300;  // 01 Jan 1997 00:00:00 GMT.

    YearMonthIntervalLit interval_1_year;
    interval_1_year.months = 12;

    DatetimeLit datetime_1998_01_01;
    datetime_1998_01_01.ticks = 883612800000300;  // 01 Jan 1998 00:00:00 GMT.

    EXPECT_EQ(datetime_1998_01_01, datetime_1997_01_01 + interval_1_year);
    EXPECT_EQ(datetime_1998_01_01, interval_1_year + datetime_1997_01_01);

    // Add YearMonthIntervalLit and YearMonthIntervalLit.
    YearMonthIntervalLit interval_2_years;
    interval_2_years.months = 24;

    EXPECT_EQ(interval_2_years, interval_1_year + interval_1_year);
  }

  void checkDatetimeAddBinaryOperation() {
    const BinaryOperation &operation(
        BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd));

    for (const pair<const TypedValue*, const Type*> &left_item : datetime_typed_values_) {
      for (const pair<const TypedValue*, const Type*> &right_item : datetime_interval_typed_values_) {
        TypedValue expected = checkDateAddBinaryOperationHelper(operation,
                                                                *left_item.first,
                                                                *left_item.second,
                                                                *right_item.first,
                                                                *right_item.second);
        checkDateBinaryOperationChecked<DatetimeLit>(operation,
                                                     *left_item.first,
                                                     *left_item.second,
                                                     *right_item.first,
                                                     *right_item.second,
                                                     expected);
        checkDateBinaryOperatorUnchecked<DatetimeLit>(operation,
                                                      *left_item.first,
                                                      *left_item.second,
                                                      *right_item.first,
                                                      *right_item.second,
                                                      expected);
      }

      for (const pair<const TypedValue*, const Type*> &right_item : year_month_interval_typed_values_) {
        TypedValue expected = checkDateAddBinaryOperationHelper(operation,
                                                                *left_item.first,
                                                                *left_item.second,
                                                                *right_item.first,
                                                                *right_item.second);
        checkDateBinaryOperationChecked<DatetimeLit>(operation,
                                                     *left_item.first,
                                                     *left_item.second,
                                                     *right_item.first,
                                                     *right_item.second,
                                                     expected);
        checkDateBinaryOperatorUnchecked<DatetimeLit>(operation,
                                                      *left_item.first,
                                                      *left_item.second,
                                                      *right_item.first,
                                                      *right_item.second,
                                                      expected);
      }
    }
  }

  void checkDatetimeIntervalAddBinaryOperation() {
    const BinaryOperation &operation(
        BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd));

    for (const pair<const TypedValue*, const Type*> &left_item : datetime_interval_typed_values_) {
      for (const pair<const TypedValue*, const Type*> &right_item : datetime_typed_values_) {
        TypedValue expected = checkDateAddBinaryOperationHelper(operation,
                                                                *left_item.first,
                                                                *left_item.second,
                                                                *right_item.first,
                                                                *right_item.second);
        checkDateBinaryOperationChecked<DatetimeLit>(operation,
                                                     *left_item.first,
                                                     *left_item.second,
                                                     *right_item.first,
                                                     *right_item.second,
                                                     expected);
        checkDateBinaryOperatorUnchecked<DatetimeLit>(operation,
                                                      *left_item.first,
                                                      *left_item.second,
                                                      *right_item.first,
                                                      *right_item.second,
                                                      expected);
      }

      for (const pair<const TypedValue*, const Type*> &right_item : datetime_interval_typed_values_) {
        TypedValue expected = checkDateAddBinaryOperationHelper(operation,
                                                                *left_item.first,
                                                                *left_item.second,
                                                                *right_item.first,
                                                                *right_item.second);
        checkDateBinaryOperationChecked<DatetimeIntervalLit>(operation,
                                                             *left_item.first,
                                                             *left_item.second,
                                                             *right_item.first,
                                                             *right_item.second,
                                                             expected);
        checkDateBinaryOperatorUnchecked<DatetimeIntervalLit>(operation,
                                                              *left_item.first,
                                                              *left_item.second,
                                                              *right_item.first,
                                                              *right_item.second,
                                                              expected);
      }
    }
  }

  void checkYearMonthIntervalAddBinaryOperation() {
    const BinaryOperation &operation(
        BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd));

    for (const pair<const TypedValue*, const Type*> &left_item : year_month_interval_typed_values_) {
      for (const pair<const TypedValue*, const Type*> &right_item : datetime_typed_values_) {
        TypedValue expected = checkDateAddBinaryOperationHelper(operation,
                                                                *left_item.first,
                                                                *left_item.second,
                                                                *right_item.first,
                                                                *right_item.second);
        checkDateBinaryOperationChecked<DatetimeLit>(operation,
                                                     *left_item.first,
                                                     *left_item.second,
                                                     *right_item.first,
                                                     *right_item.second,
                                                     expected);
        checkDateBinaryOperatorUnchecked<DatetimeLit>(operation,
                                                      *left_item.first,
                                                      *left_item.second,
                                                      *right_item.first,
                                                      *right_item.second,
                                                      expected);
      }

      for (const pair<const TypedValue*, const Type*> &right_item : year_month_interval_typed_values_) {
        TypedValue expected = checkDateAddBinaryOperationHelper(operation,
                                                                *left_item.first,
                                                                *left_item.second,
                                                                *right_item.first,
                                                                *right_item.second);
        checkDateBinaryOperationChecked<YearMonthIntervalLit>(operation,
                                                              *left_item.first,
                                                              *left_item.second,
                                                              *right_item.first,
                                                              *right_item.second,
                                                              expected);
        checkDateBinaryOperatorUnchecked<YearMonthIntervalLit>(operation,
                                                               *left_item.first,
                                                               *left_item.second,
                                                               *right_item.first,
                                                               *right_item.second,
                                                               expected);
      }
    }
  }

  void checkDateSubtractBinaryOperators() {
    // Subtract DatetimeLit and DatetimeLit.
    DatetimeLit datetime_1998_12_01;
    datetime_1998_12_01.ticks = 912470400600000;  // 01 Dec 1998 00:00:00 GMT.

    DatetimeIntervalLit interval_96_days;
    interval_96_days.interval_ticks = 8294400000000;

    DatetimeLit datetime_1998_8_27;
    datetime_1998_8_27.ticks = 904176000600000;  // 27 Aug 1998 00:00:00 GMT.

    EXPECT_EQ(interval_96_days, datetime_1998_12_01 - datetime_1998_8_27);

    // Subtract DatetimeIntervalLit and DatetimeIntervalLit.
    DatetimeIntervalLit interval_48_days;
    interval_48_days.interval_ticks = 4147200000000;

    EXPECT_EQ(interval_48_days, interval_96_days - interval_48_days);

    // Subtract DatetimeLit and YearMonthIntervalLit.
    DatetimeLit datetime_2014_12_26;
    datetime_2014_12_26.ticks = 1419552000000001;  // 26 Dec 2014 00:00:00 GMT.

    YearMonthIntervalLit interval_6_months;
    interval_6_months.months = 6;

    DatetimeLit datetime_2014_06_26;
    datetime_2014_06_26.ticks = 1403740800000001;  // 26 Jun 2014 00:00:00 GMT.

    EXPECT_EQ(datetime_2014_06_26, datetime_2014_12_26 - interval_6_months);

    // Subtract DatetimeLit and YearMonthIntervalLit.
    YearMonthIntervalLit interval_1_year;
    interval_1_year.months = 12;

    EXPECT_EQ(interval_6_months, interval_1_year - interval_6_months);
  }

  void checkDatetimeSubtractBinaryOperation() {
    const BinaryOperation &operation(
        BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kSubtract));

    for (const pair<const TypedValue*, const Type*> &left_item : datetime_typed_values_) {
      for (const pair<const TypedValue*, const Type*> &right_item : datetime_typed_values_) {
        TypedValue expected = checkDateSubtractBinaryOperationHelper(operation,
                                                                     *left_item.first,
                                                                     *left_item.second,
                                                                     *right_item.first,
                                                                     *right_item.second);
        checkDateBinaryOperationChecked<DatetimeIntervalLit>(operation,
                                                             *left_item.first,
                                                             *left_item.second,
                                                             *right_item.first,
                                                             *right_item.second,
                                                             expected);
        checkDateBinaryOperatorUnchecked<DatetimeIntervalLit>(operation,
                                                              *left_item.first,
                                                              *left_item.second,
                                                              *right_item.first,
                                                              *right_item.second,
                                                              expected);
      }

      for (const pair<const TypedValue*, const Type*> &right_item : datetime_interval_typed_values_) {
        TypedValue expected = checkDateSubtractBinaryOperationHelper(operation,
                                                                     *left_item.first,
                                                                     *left_item.second,
                                                                     *right_item.first,
                                                                     *right_item.second);
        checkDateBinaryOperationChecked<DatetimeLit>(operation,
                                                     *left_item.first,
                                                     *left_item.second,
                                                     *right_item.first,
                                                     *right_item.second,
                                                     expected);
        checkDateBinaryOperatorUnchecked<DatetimeLit>(operation,
                                                      *left_item.first,
                                                      *left_item.second,
                                                      *right_item.first,
                                                      *right_item.second,
                                                      expected);
      }

      for (const pair<const TypedValue*, const Type*> &right_item : year_month_interval_typed_values_) {
        TypedValue expected = checkDateSubtractBinaryOperationHelper(operation,
                                                                     *left_item.first,
                                                                     *left_item.second,
                                                                     *right_item.first,
                                                                     *right_item.second);
        checkDateBinaryOperationChecked<DatetimeLit>(operation,
                                                     *left_item.first,
                                                     *left_item.second,
                                                     *right_item.first,
                                                     *right_item.second,
                                                     expected);
        checkDateBinaryOperatorUnchecked<DatetimeLit>(operation,
                                                      *left_item.first,
                                                      *left_item.second,
                                                      *right_item.first,
                                                      *right_item.second,
                                                      expected);
      }
    }
  }

  void checkDatetimeIntervalSubtractBinaryOperation() {
    const BinaryOperation &operation(
        BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kSubtract));

    for (const pair<const TypedValue*, const Type*> &left_item : datetime_interval_typed_values_) {
      for (const pair<const TypedValue*, const Type*> &right_item : datetime_interval_typed_values_) {
        TypedValue expected = checkDateSubtractBinaryOperationHelper(operation,
                                                                     *left_item.first,
                                                                     *left_item.second,
                                                                     *right_item.first,
                                                                     *right_item.second);
        checkDateBinaryOperationChecked<DatetimeIntervalLit>(operation,
                                                             *left_item.first,
                                                             *left_item.second,
                                                             *right_item.first,
                                                             *right_item.second,
                                                             expected);
        checkDateBinaryOperatorUnchecked<DatetimeIntervalLit>(operation,
                                                              *left_item.first,
                                                              *left_item.second,
                                                              *right_item.first,
                                                              *right_item.second,
                                                              expected);
      }
    }
  }

  void checkYearMonthIntervalSubtractBinaryOperation() {
    const BinaryOperation &operation(
        BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kSubtract));

    for (const pair<const TypedValue*, const Type*> &left_item : year_month_interval_typed_values_) {
      for (const pair<const TypedValue*, const Type*> &right_item : year_month_interval_typed_values_) {
        TypedValue expected = checkDateSubtractBinaryOperationHelper(operation,
                                                                     *left_item.first,
                                                                     *left_item.second,
                                                                     *right_item.first,
                                                                     *right_item.second);
        checkDateBinaryOperationChecked<YearMonthIntervalLit>(operation,
                                                              *left_item.first,
                                                              *left_item.second,
                                                              *right_item.first,
                                                              *right_item.second,
                                                              expected);
        checkDateBinaryOperatorUnchecked<YearMonthIntervalLit>(operation,
                                                               *left_item.first,
                                                               *left_item.second,
                                                               *right_item.first,
                                                               *right_item.second,
                                                               expected);
      }
    }
  }

  void checkDateMultiplyBinaryOperators() {
    // DatetimeIntervalLit Multiplication.
    DatetimeIntervalLit interval_32_days;
    interval_32_days.interval_ticks = 2764800000000;

    DatetimeIntervalLit interval_96_days;
    interval_96_days.interval_ticks = 8294400000000;

    EXPECT_EQ(interval_96_days, interval_32_days * 3);
    EXPECT_EQ(interval_96_days, 3 * interval_32_days);

    // YearMonthIntervalLit Multiplication.
    YearMonthIntervalLit interval_6_months;
    interval_6_months.months = 6;

    YearMonthIntervalLit interval_2_years;
    interval_2_years.months = 24;

    EXPECT_EQ(interval_2_years, interval_6_months * 4);
    EXPECT_EQ(interval_2_years, 4 * interval_6_months);
  }

  void checkDatetimeIntervalMultiplyBinaryOperation() {
    const BinaryOperation &operation(
        BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kMultiply));

    for (const pair<const TypedValue*, const Type*> &left_item : datetime_interval_typed_values_) {
      for (const pair<const TypedValue*, const Type*> &right_item : numeric_typed_values_) {
        TypedValue expected = checkDateMultiplyBinaryOperationHelper(operation,
                                                                     *left_item.first,
                                                                     *left_item.second,
                                                                     *right_item.first,
                                                                     *right_item.second);
        checkDateBinaryOperationChecked<DatetimeIntervalLit>(operation,
                                                             *left_item.first,
                                                             *left_item.second,
                                                             *right_item.first,
                                                             *right_item.second,
                                                             expected);
        checkDateBinaryOperatorUnchecked<DatetimeIntervalLit>(operation,
                                                              *left_item.first,
                                                              *left_item.second,
                                                              *right_item.first,
                                                              *right_item.second,
                                                              expected);

        // Should also get same results with arguments reversed.
        checkDateBinaryOperationChecked<DatetimeIntervalLit>(operation,
                                                             *right_item.first,
                                                             *right_item.second,
                                                             *left_item.first,
                                                             *left_item.second,
                                                             expected);
        checkDateBinaryOperatorUnchecked<DatetimeIntervalLit>(operation,
                                                              *right_item.first,
                                                              *right_item.second,
                                                              *left_item.first,
                                                              *left_item.second,
                                                              expected);
      }
    }
  }

  void checkYearMonthIntervalMultiplyBinaryOperation() {
    const BinaryOperation &operation(
        BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kMultiply));

    for (const pair<const TypedValue*, const Type*> &left_item : year_month_interval_typed_values_) {
      for (const pair<const TypedValue*, const Type*> &right_item : numeric_typed_values_) {
        TypedValue expected = checkDateMultiplyBinaryOperationHelper(operation,
                                                                     *left_item.first,
                                                                     *left_item.second,
                                                                     *right_item.first,
                                                                     *right_item.second);
        checkDateBinaryOperationChecked<YearMonthIntervalLit>(operation,
                                                              *left_item.first,
                                                              *left_item.second,
                                                              *right_item.first,
                                                              *right_item.second,
                                                              expected);
        checkDateBinaryOperatorUnchecked<YearMonthIntervalLit>(operation,
                                                               *left_item.first,
                                                               *left_item.second,
                                                               *right_item.first,
                                                               *right_item.second,
                                                               expected);

        // Should also get same results with arguments reversed.
        checkDateBinaryOperationChecked<YearMonthIntervalLit>(operation,
                                                              *right_item.first,
                                                              *right_item.second,
                                                              *left_item.first,
                                                              *left_item.second,
                                                              expected);
        checkDateBinaryOperatorUnchecked<YearMonthIntervalLit>(operation,
                                                               *right_item.first,
                                                               *right_item.second,
                                                               *left_item.first,
                                                               *left_item.second,
                                                               expected);
      }
    }
  }

  void checkDateDivideBinaryOperators() {
    // DatetimeIntervalLit Division.
    DatetimeIntervalLit interval_96_days;
    interval_96_days.interval_ticks = 8294400000000;

    DatetimeIntervalLit interval_32_days;
    interval_32_days.interval_ticks = 2764800000000;

    EXPECT_EQ(interval_32_days, interval_96_days / 3);

    // YearMonthIntervalLit Division.
    YearMonthIntervalLit interval_2_years;
    interval_2_years.months = 24;

    YearMonthIntervalLit interval_6_months;
    interval_6_months.months = 6;

    EXPECT_EQ(interval_6_months, interval_2_years / 4);
  }

  void checkDatetimeIntervalDivideBinaryOperation() {
    const BinaryOperation &operation(
        BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kDivide));

    for (const pair<const TypedValue*, const Type*> &left_item : datetime_interval_typed_values_) {
      for (const pair<const TypedValue*, const Type*> &right_item : numeric_typed_values_) {
        if (!right_item.first->isNull() &&
            TypedValueIsZero(*right_item.first)) {
          // Avoid Divide-by-zero errors.
          continue;
        }

        TypedValue expected = checkDateDivideBinaryOperationHelper(operation,
                                                                   *left_item.first,
                                                                   *left_item.second,
                                                                   *right_item.first,
                                                                   *right_item.second);
        checkDateBinaryOperationChecked<DatetimeIntervalLit>(operation,
                                                             *left_item.first,
                                                             *left_item.second,
                                                             *right_item.first,
                                                             *right_item.second,
                                                             expected);
        checkDateBinaryOperatorUnchecked<DatetimeIntervalLit>(operation,
                                                              *left_item.first,
                                                              *left_item.second,
                                                              *right_item.first,
                                                              *right_item.second,
                                                              expected);
      }
    }
  }

  void checkYearMonthIntervalDivideBinaryOperation() {
    const BinaryOperation &operation(
        BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kDivide));

    for (const pair<const TypedValue*, const Type*> &left_item : year_month_interval_typed_values_) {
      for (const pair<const TypedValue*, const Type*> &right_item : numeric_typed_values_) {
        if (!right_item.first->isNull() &&
            TypedValueIsZero(*right_item.first)) {
          // Avoid Divide-by-zero errors.
          continue;
        }

        TypedValue expected = checkDateDivideBinaryOperationHelper(operation,
                                                                   *left_item.first,
                                                                   *left_item.second,
                                                                   *right_item.first,
                                                                   *right_item.second);
        checkDateBinaryOperationChecked<YearMonthIntervalLit>(operation,
                                                              *left_item.first,
                                                              *left_item.second,
                                                              *right_item.first,
                                                              *right_item.second,
                                                              expected);
        checkDateBinaryOperatorUnchecked<YearMonthIntervalLit>(operation,
                                                               *left_item.first,
                                                               *left_item.second,
                                                               *right_item.first,
                                                               *right_item.second,
                                                               expected);
      }
    }
  }

 private:
  void checkNumericBinaryOperationChecked(const BinaryOperation &operation,
                                          const TypedValue &left,
                                          const Type &left_type,
                                          const TypedValue &right,
                                          const Type &right_type) {
    if (left.isNull() || right.isNull()) {
      EXPECT_TRUE(operation.applyToChecked(left, left_type, right, right_type).isNull());
      return;
    }

    const Type* expected_type =
        operation.resultTypeForArgumentTypes(left_type, right_type);
    ASSERT_NE(expected_type, nullptr);

    switch (expected_type->getTypeID()) {
      case kInt:
        checkNumericBinaryOperationCheckedHelper<int>(operation,
                                                      left,
                                                      left_type,
                                                      right,
                                                      right_type);
        break;
      case kLong:
        checkNumericBinaryOperationCheckedHelper<int64_t>(operation,
                                                          left,
                                                          left_type,
                                                          right,
                                                          right_type);
        break;
      case kFloat:
        checkNumericBinaryOperationCheckedHelper<float>(operation,
                                                        left,
                                                        left_type,
                                                        right,
                                                        right_type);
        break;
      case kDouble:
        checkNumericBinaryOperationCheckedHelper<double>(operation,
                                                         left,
                                                         left_type,
                                                         right,
                                                         right_type);
        break;
      default:
        FATAL_ERROR("Unsupported result type from two operands.");
    }
  }

  template <typename NumericType>
  inline void checkNumericBinaryOperationCheckedHelper(const BinaryOperation &operation,
                                                       const TypedValue &left,
                                                       const Type &left_type,
                                                       const TypedValue &right,
                                                       const Type &right_type) {
    NumericType expected = checkNumericBinaryOperationHelper<NumericType>(operation, left, right);
    EXPECT_EQ(expected, operation.applyToChecked(left, left_type,
                                                 right, right_type).getLiteral<NumericType>());
  }

  void checkNumericBinaryOperatorUnchecked(const BinaryOperation &operation,
                                           const TypedValue &left,
                                           const Type &left_type,
                                           const TypedValue &right,
                                           const Type &right_type) {
    unique_ptr<UncheckedBinaryOperator> binary_operator(
        operation.makeUncheckedBinaryOperatorForTypes(left_type,
                                                      right_type));

    if (left.isNull() || right.isNull()) {
      EXPECT_TRUE(binary_operator->applyToTypedValues(left, right).isNull());
      EXPECT_TRUE(binary_operator->applyToDataPtrs(
          left.isNull() ? nullptr : left.getDataPtr(),
          right.isNull() ? nullptr : right.getDataPtr()).isNull());
      return;
    }

    const Type *expected_type =
        operation.resultTypeForArgumentTypes(left_type, right_type);
    ASSERT_NE(expected_type, nullptr);

    switch (expected_type->getTypeID()) {
      case kInt:
        checkNumericBinaryOperatorUncheckedHelper<int>(operation, *binary_operator, left, right);
        break;
      case kLong:
        checkNumericBinaryOperatorUncheckedHelper<int64_t>(operation, *binary_operator, left, right);
        break;
      case kFloat:
        checkNumericBinaryOperatorUncheckedHelper<float>(operation, *binary_operator, left, right);
        break;
      case kDouble:
        checkNumericBinaryOperatorUncheckedHelper<double>(operation, *binary_operator, left, right);
        break;
      default:
        FATAL_ERROR("Unsupported result types from two operands.");
    }
  }

  template <typename NumericType>
  inline void checkNumericBinaryOperatorUncheckedHelper(const BinaryOperation &operation,
                                                        const UncheckedBinaryOperator &binary_operator,
                                                        const TypedValue &left,
                                                        const TypedValue &right) {
    NumericType expected = checkNumericBinaryOperationHelper<NumericType>(operation, left, right);
    EXPECT_EQ(expected, binary_operator.applyToTypedValues(left, right).getLiteral<NumericType>());
    EXPECT_EQ(expected,
              binary_operator.applyToDataPtrs(left.getDataPtr(),
                                              right.getDataPtr()).getLiteral<NumericType>());
  }

  template <typename NumericType>
  inline NumericType checkNumericBinaryOperationHelper(const BinaryOperation &operation,
                                                       const TypedValue &left,
                                                       const TypedValue &right) {
    const NumericType left_num = GetTypedValueAsNumeric<NumericType>(left);
    const NumericType right_num = GetTypedValueAsNumeric<NumericType>(right);
    switch (operation.getBinaryOperationID()) {
      case BinaryOperationID::kAdd:
        return left_num + right_num;
      case BinaryOperationID::kSubtract:
        return left_num - right_num;
      case BinaryOperationID::kMultiply:
        return left_num * right_num;
      case BinaryOperationID::kDivide:
        CHECK_NE(right_num, static_cast<NumericType>(0));
        return left_num / right_num;
      default:
        FATAL_ERROR("Unsupported numeric binary operation.");
    }
  }

  inline TypedValue checkDateAddBinaryOperationHelper(const BinaryOperation &operation,
                                                      const TypedValue &left,
                                                      const Type &left_type,
                                                      const TypedValue &right,
                                                      const Type &right_type) {
    if (left.isNull() || right.isNull()) {
      return operation.resultTypeForArgumentTypes(left_type, right_type)->makeNullValue();
    }

    switch (left_type.getTypeID()) {
      case kDatetime:
        switch (right_type.getTypeID()) {
          case kDatetimeInterval:
            return TypedValue(left.getLiteral<DatetimeLit>() + right.getLiteral<DatetimeIntervalLit>());
          case kYearMonthInterval:
            return TypedValue(left.getLiteral<DatetimeLit>() + right.getLiteral<YearMonthIntervalLit>());
          default:
            break;
        }
        break;
      case kDatetimeInterval:
        switch (right_type.getTypeID()) {
          case kDatetime:
            return TypedValue(left.getLiteral<DatetimeIntervalLit>() + right.getLiteral<DatetimeLit>());
          case kDatetimeInterval:
            return TypedValue(left.getLiteral<DatetimeIntervalLit>() + right.getLiteral<DatetimeIntervalLit>());
          default:
            break;
        }
        break;
      case kYearMonthInterval:
        switch (right_type.getTypeID()) {
          case kDatetime:
            return TypedValue(left.getLiteral<YearMonthIntervalLit>() + right.getLiteral<DatetimeLit>());
          case kYearMonthInterval:
            return TypedValue(left.getLiteral<YearMonthIntervalLit>() + right.getLiteral<YearMonthIntervalLit>());
          default:
            break;
        }
        break;
      default:
        break;
    }

    FATAL_ERROR("Unsupported add between two operands.");
  }

  inline TypedValue checkDateSubtractBinaryOperationHelper(const BinaryOperation &operation,
                                                           const TypedValue &left,
                                                           const Type &left_type,
                                                           const TypedValue &right,
                                                           const Type &right_type) {
    if (left.isNull() || right.isNull()) {
      return operation.resultTypeForArgumentTypes(left_type, right_type)->makeNullValue();
    }

    switch (left_type.getTypeID()) {
      case kDatetime:
        switch (right_type.getTypeID()) {
          case kDatetime:
            return TypedValue(left.getLiteral<DatetimeLit>() - right.getLiteral<DatetimeLit>());
          case kDatetimeInterval:
            return TypedValue(left.getLiteral<DatetimeLit>() - right.getLiteral<DatetimeIntervalLit>());
          case kYearMonthInterval:
            return TypedValue(left.getLiteral<DatetimeLit>() - right.getLiteral<YearMonthIntervalLit>());
          default:
            break;
        }
        break;
      case kDatetimeInterval:
        switch (right_type.getTypeID()) {
          case kDatetimeInterval:
            return TypedValue(left.getLiteral<DatetimeIntervalLit>() - right.getLiteral<DatetimeIntervalLit>());
          default:
            break;
        }
        break;
      case kYearMonthInterval:
        switch (right_type.getTypeID()) {
          case kYearMonthInterval:
            return TypedValue(left.getLiteral<YearMonthIntervalLit>() - right.getLiteral<YearMonthIntervalLit>());
          default:
            break;
        }
        break;
      default:
        break;
    }

    FATAL_ERROR("Unsupported subtraction between two operands.");
  }

  inline TypedValue checkDateMultiplyBinaryOperationHelper(const BinaryOperation &operation,
                                                           const TypedValue &left,
                                                           const Type &left_type,
                                                           const TypedValue &right,
                                                           const Type &right_type) {
    if (left.isNull() || right.isNull()) {
      return operation.resultTypeForArgumentTypes(left_type, right_type)->makeNullValue();
    }

    switch (left_type.getTypeID()) {
      case kInt:
        switch (right_type.getTypeID()) {
          case kDatetimeInterval:
            return TypedValue(right.getLiteral<DatetimeIntervalLit>() * left.getLiteral<int>());
          case kYearMonthInterval:
            return TypedValue(right.getLiteral<YearMonthIntervalLit>() * left.getLiteral<int>());
          default:
            break;
        }
        break;
      case kLong:
        switch (right_type.getTypeID()) {
          case kDatetimeInterval:
            return TypedValue(right.getLiteral<DatetimeIntervalLit>() * left.getLiteral<int64_t>());
          case kYearMonthInterval:
            return TypedValue(right.getLiteral<YearMonthIntervalLit>() * left.getLiteral<int64_t>());
          default:
            break;
        }
        break;
      case kFloat:
        switch (right_type.getTypeID()) {
          case kDatetimeInterval:
            return TypedValue(right.getLiteral<DatetimeIntervalLit>() * left.getLiteral<float>());
          case kYearMonthInterval:
            return TypedValue(right.getLiteral<YearMonthIntervalLit>() * left.getLiteral<float>());
          default:
            break;
        }
        break;
      case kDouble:
        switch (right_type.getTypeID()) {
          case kDatetimeInterval:
            return TypedValue(right.getLiteral<DatetimeIntervalLit>() * left.getLiteral<double>());
          case kYearMonthInterval:
            return TypedValue(right.getLiteral<YearMonthIntervalLit>() * left.getLiteral<double>());
          default:
            break;
        }
        break;
      case kDatetimeInterval:
        switch (right_type.getTypeID()) {
          case kInt:
            return TypedValue(left.getLiteral<DatetimeIntervalLit>() * right.getLiteral<int>());
          case kLong:
            return TypedValue(left.getLiteral<DatetimeIntervalLit>() * right.getLiteral<int64_t>());
          case kFloat:
            return TypedValue(left.getLiteral<DatetimeIntervalLit>() * right.getLiteral<float>());
          case kDouble:
            return TypedValue(left.getLiteral<DatetimeIntervalLit>() * right.getLiteral<double>());
          default:
            break;
        }
        break;
      case kYearMonthInterval:
        switch (right_type.getTypeID()) {
          case kInt:
            return TypedValue(left.getLiteral<YearMonthIntervalLit>() * right.getLiteral<int>());
          case kLong:
            return TypedValue(left.getLiteral<YearMonthIntervalLit>() * right.getLiteral<int64_t>());
          case kFloat:
            return TypedValue(left.getLiteral<YearMonthIntervalLit>() * right.getLiteral<float>());
          case kDouble:
            return TypedValue(left.getLiteral<YearMonthIntervalLit>() * right.getLiteral<double>());
          default:
            break;
        }
        break;
      default:
        break;
    }

    FATAL_ERROR("Unsupported multiplication between two operands.");
  }

  inline TypedValue checkDateDivideBinaryOperationHelper(const BinaryOperation &operation,
                                                         const TypedValue &left,
                                                         const Type &left_type,
                                                         const TypedValue &right,
                                                         const Type &right_type) {
    if (left.isNull() || right.isNull()) {
      return operation.resultTypeForArgumentTypes(left_type, right_type)->makeNullValue();
    }

    switch (left_type.getTypeID()) {
      case kDatetimeInterval:
        switch (right_type.getTypeID()) {
          case kInt:
            return TypedValue(left.getLiteral<DatetimeIntervalLit>() / right.getLiteral<int>());
          case kLong:
            return TypedValue(left.getLiteral<DatetimeIntervalLit>() / right.getLiteral<int64_t>());
          case kFloat:
            return TypedValue(left.getLiteral<DatetimeIntervalLit>() / right.getLiteral<float>());
          case kDouble:
            return TypedValue(left.getLiteral<DatetimeIntervalLit>() / right.getLiteral<double>());
          default:
            break;
        }
        break;
      case kYearMonthInterval:
        switch (right_type.getTypeID()) {
          case kInt:
            return TypedValue(left.getLiteral<YearMonthIntervalLit>() / right.getLiteral<int>());
          case kLong:
            return TypedValue(left.getLiteral<YearMonthIntervalLit>() / right.getLiteral<int64_t>());
          case kFloat:
            return TypedValue(left.getLiteral<YearMonthIntervalLit>() / right.getLiteral<float>());
          case kDouble:
            return TypedValue(left.getLiteral<YearMonthIntervalLit>() / right.getLiteral<double>());
          default:
            break;
        }
        break;
      default:
        break;
    }

    FATAL_ERROR("Unsupported division between two operands.");
  }

  template <typename DateType>
  void checkDateBinaryOperationChecked(const BinaryOperation &operation,
                                       const TypedValue &left,
                                       const Type &left_type,
                                       const TypedValue &right,
                                       const Type &right_type,
                                       const TypedValue &expected) {
    if (left.isNull() || right.isNull()) {
      EXPECT_TRUE(operation.applyToChecked(left, left_type, right, right_type).isNull());
      return;
    }

    TypedValue checked(operation.applyToChecked(left, left_type, right, right_type));
    EXPECT_EQ(expected.getLiteral<DateType>(),
              checked.getLiteral<DateType>());
  }

  template <typename DateType>
  void checkDateBinaryOperatorUnchecked(const BinaryOperation &operation,
                                        const TypedValue &left,
                                        const Type &left_type,
                                        const TypedValue &right,
                                        const Type &right_type,
                                        const TypedValue &expected) {
    unique_ptr<UncheckedBinaryOperator> binary_operator(
        operation.makeUncheckedBinaryOperatorForTypes(left_type, right_type));

    if (left.isNull() || right.isNull()) {
      EXPECT_TRUE(binary_operator->applyToTypedValues(left, right).isNull());
      EXPECT_TRUE(binary_operator->applyToDataPtrs(
          left.isNull() ? nullptr : left.getDataPtr(),
          right.isNull() ? nullptr : right.getDataPtr()).isNull());
      return;
    }

    TypedValue checked(binary_operator->applyToTypedValues(left, right));
    EXPECT_EQ(expected.getLiteral<DateType>(),
              checked.getLiteral<DateType>());

    TypedValue checked_from_date_ptr(binary_operator->applyToDataPtrs(left.getDataPtr(),
                                                                      right.getDataPtr()));
    EXPECT_EQ(expected.getLiteral<DateType>(),
              checked_from_date_ptr.getLiteral<DateType>());
  }

  unique_ptr<TypedValue>
      int_null_, int_zero_, int_positive_, int_negative_, int_max_, int_min_,
      long_null_, long_zero_, long_positive_, long_negative_, long_max_, long_min_,
      float_null_, float_zero_, float_positive_, float_negative_, float_max_, float_min_,
      double_null_, double_zero_, double_positive_, double_negative_, double_max_, double_min_,
      datetime_null_, datetime_zero_, datetime_positive_, datetime_negative_, datetime_max_, datetime_min_,
      datetime_interval_null_, datetime_interval_zero_, datetime_interval_positive_, datetime_interval_negative_,
      year_month_interval_null_, year_month_interval_zero_,
      year_month_interval_positive_, year_month_interval_negative_;

  vector<pair<const TypedValue*, const Type*>>
      numeric_typed_values_, datetime_typed_values_,
      datetime_interval_typed_values_, year_month_interval_typed_values_;
};

TEST_F(BinaryOperationTest, AddBinaryOperationTest) {
  checkNumericBinaryOperation(
      BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd));
  checkDateAddBinaryOperators();
  checkDatetimeAddBinaryOperation();
  checkDatetimeIntervalAddBinaryOperation();
  checkYearMonthIntervalAddBinaryOperation();
}

TEST_F(BinaryOperationTest, SubtractBinaryOperationTest) {
  checkNumericBinaryOperation(
      BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kSubtract));
  checkDateSubtractBinaryOperators();
  checkDatetimeSubtractBinaryOperation();
  checkDatetimeIntervalSubtractBinaryOperation();
  checkYearMonthIntervalSubtractBinaryOperation();
}

TEST_F(BinaryOperationTest, MultiplyBinaryOperationTest) {
  checkNumericBinaryOperation(
      BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kMultiply));
  checkDateMultiplyBinaryOperators();
  // NOTE(zuyu): No multiplication operations for the Datetime type.
  checkDatetimeIntervalMultiplyBinaryOperation();
  checkYearMonthIntervalMultiplyBinaryOperation();
}

TEST_F(BinaryOperationTest, DivideBinaryOperationTest) {
  checkNumericBinaryOperation(
      BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kDivide));
  checkDateDivideBinaryOperators();
  // NOTE(zuyu): No division operations for the Datetime type.
  checkDatetimeIntervalDivideBinaryOperation();
  checkYearMonthIntervalDivideBinaryOperation();
}


void CheckBinaryOperationSerialization(const BinaryOperation &operation) {
  serialization::BinaryOperation proto = operation.getProto();
  switch (operation.getBinaryOperationID()) {
    case BinaryOperationID::kAdd:
      EXPECT_EQ(serialization::BinaryOperation::ADD, proto.operation_id());
      break;
    case BinaryOperationID::kSubtract:
      EXPECT_EQ(serialization::BinaryOperation::SUBTRACT, proto.operation_id());
      break;
    case BinaryOperationID::kMultiply:
      EXPECT_EQ(serialization::BinaryOperation::MULTIPLY, proto.operation_id());
      break;
    case BinaryOperationID::kDivide:
      EXPECT_EQ(serialization::BinaryOperation::DIVIDE, proto.operation_id());
      break;
    case BinaryOperationID::kModulo:
      EXPECT_EQ(serialization::BinaryOperation::MODULO, proto.operation_id());
      break;
    default:
      FATAL_ERROR("operation is an unknown BinaryOperation in CheckBinaryOperationSerialization");
  }

  EXPECT_TRUE(operation.equals(BinaryOperationFactory::ReconstructFromProto(proto)));
}

TEST(BinaryOperationSerializationTest, BinaryOperationProtoSerializationTest) {
  CheckBinaryOperationSerialization(BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd));

  CheckBinaryOperationSerialization(BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kSubtract));

  CheckBinaryOperationSerialization(BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kMultiply));

  CheckBinaryOperationSerialization(BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kDivide));
}

}  // namespace quickstep