/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * Licensed 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 "Model.pb.h"
#include "TestHarness.h"

namespace android::nn::fuzz {
namespace {

using namespace test_helper;

static_assert(static_cast<TestOperandType>(FLOAT32) == TestOperandType::FLOAT32);
static_assert(static_cast<TestOperandType>(INT32) == TestOperandType::INT32);
static_assert(static_cast<TestOperandType>(UINT32) == TestOperandType::UINT32);
static_assert(static_cast<TestOperandType>(TENSOR_FLOAT32) == TestOperandType::TENSOR_FLOAT32);
static_assert(static_cast<TestOperandType>(TENSOR_INT32) == TestOperandType::TENSOR_INT32);
static_assert(static_cast<TestOperandType>(TENSOR_QUANT8_ASYMM) ==
              TestOperandType::TENSOR_QUANT8_ASYMM);
static_assert(static_cast<TestOperandType>(BOOL) == TestOperandType::BOOL);
static_assert(static_cast<TestOperandType>(TENSOR_QUANT16_SYMM) ==
              TestOperandType::TENSOR_QUANT16_SYMM);
static_assert(static_cast<TestOperandType>(TENSOR_FLOAT16) == TestOperandType::TENSOR_FLOAT16);
static_assert(static_cast<TestOperandType>(TENSOR_BOOL8) == TestOperandType::TENSOR_BOOL8);
static_assert(static_cast<TestOperandType>(FLOAT16) == TestOperandType::FLOAT16);
static_assert(static_cast<TestOperandType>(TENSOR_QUANT8_SYMM_PER_CHANNEL) ==
              TestOperandType::TENSOR_QUANT8_SYMM_PER_CHANNEL);
static_assert(static_cast<TestOperandType>(TENSOR_QUANT16_ASYMM) ==
              TestOperandType::TENSOR_QUANT16_ASYMM);
static_assert(static_cast<TestOperandType>(TENSOR_QUANT8_SYMM) ==
              TestOperandType::TENSOR_QUANT8_SYMM);
static_assert(static_cast<TestOperandType>(TENSOR_QUANT8_ASYMM_SIGNED) ==
              TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED);
static_assert(static_cast<TestOperandType>(SUBGRAPH_OPERAND) == TestOperandType::SUBGRAPH);

static_assert(static_cast<TestOperationType>(ADD) == TestOperationType::ADD);
static_assert(static_cast<TestOperationType>(AVERAGE_POOL_2D) ==
              TestOperationType::AVERAGE_POOL_2D);
static_assert(static_cast<TestOperationType>(CONCATENATION) == TestOperationType::CONCATENATION);
static_assert(static_cast<TestOperationType>(CONV_2D) == TestOperationType::CONV_2D);
static_assert(static_cast<TestOperationType>(DEPTHWISE_CONV_2D) ==
              TestOperationType::DEPTHWISE_CONV_2D);
static_assert(static_cast<TestOperationType>(DEPTH_TO_SPACE) == TestOperationType::DEPTH_TO_SPACE);
static_assert(static_cast<TestOperationType>(DEQUANTIZE) == TestOperationType::DEQUANTIZE);
static_assert(static_cast<TestOperationType>(EMBEDDING_LOOKUP) ==
              TestOperationType::EMBEDDING_LOOKUP);
static_assert(static_cast<TestOperationType>(FLOOR) == TestOperationType::FLOOR);
static_assert(static_cast<TestOperationType>(FULLY_CONNECTED) ==
              TestOperationType::FULLY_CONNECTED);
static_assert(static_cast<TestOperationType>(HASHTABLE_LOOKUP) ==
              TestOperationType::HASHTABLE_LOOKUP);
static_assert(static_cast<TestOperationType>(L2_NORMALIZATION) ==
              TestOperationType::L2_NORMALIZATION);
static_assert(static_cast<TestOperationType>(L2_POOL_2D) == TestOperationType::L2_POOL_2D);
static_assert(static_cast<TestOperationType>(LOCAL_RESPONSE_NORMALIZATION) ==
              TestOperationType::LOCAL_RESPONSE_NORMALIZATION);
static_assert(static_cast<TestOperationType>(LOGISTIC) == TestOperationType::LOGISTIC);
static_assert(static_cast<TestOperationType>(LSH_PROJECTION) == TestOperationType::LSH_PROJECTION);
static_assert(static_cast<TestOperationType>(LSTM) == TestOperationType::LSTM);
static_assert(static_cast<TestOperationType>(MAX_POOL_2D) == TestOperationType::MAX_POOL_2D);
static_assert(static_cast<TestOperationType>(MUL) == TestOperationType::MUL);
static_assert(static_cast<TestOperationType>(RELU) == TestOperationType::RELU);
static_assert(static_cast<TestOperationType>(RELU1) == TestOperationType::RELU1);
static_assert(static_cast<TestOperationType>(RELU6) == TestOperationType::RELU6);
static_assert(static_cast<TestOperationType>(RESHAPE) == TestOperationType::RESHAPE);
static_assert(static_cast<TestOperationType>(RESIZE_BILINEAR) ==
              TestOperationType::RESIZE_BILINEAR);
static_assert(static_cast<TestOperationType>(RNN) == TestOperationType::RNN);
static_assert(static_cast<TestOperationType>(SOFTMAX) == TestOperationType::SOFTMAX);
static_assert(static_cast<TestOperationType>(SPACE_TO_DEPTH) == TestOperationType::SPACE_TO_DEPTH);
static_assert(static_cast<TestOperationType>(SVDF) == TestOperationType::SVDF);
static_assert(static_cast<TestOperationType>(TANH) == TestOperationType::TANH);
static_assert(static_cast<TestOperationType>(BATCH_TO_SPACE_ND) ==
              TestOperationType::BATCH_TO_SPACE_ND);
static_assert(static_cast<TestOperationType>(DIV) == TestOperationType::DIV);
static_assert(static_cast<TestOperationType>(MEAN) == TestOperationType::MEAN);
static_assert(static_cast<TestOperationType>(PAD) == TestOperationType::PAD);
static_assert(static_cast<TestOperationType>(SPACE_TO_BATCH_ND) ==
              TestOperationType::SPACE_TO_BATCH_ND);
static_assert(static_cast<TestOperationType>(SQUEEZE) == TestOperationType::SQUEEZE);
static_assert(static_cast<TestOperationType>(STRIDED_SLICE) == TestOperationType::STRIDED_SLICE);
static_assert(static_cast<TestOperationType>(SUB) == TestOperationType::SUB);
static_assert(static_cast<TestOperationType>(TRANSPOSE) == TestOperationType::TRANSPOSE);
static_assert(static_cast<TestOperationType>(ABS) == TestOperationType::ABS);
static_assert(static_cast<TestOperationType>(ARGMAX) == TestOperationType::ARGMAX);
static_assert(static_cast<TestOperationType>(ARGMIN) == TestOperationType::ARGMIN);
static_assert(static_cast<TestOperationType>(AXIS_ALIGNED_BBOX_TRANSFORM) ==
              TestOperationType::AXIS_ALIGNED_BBOX_TRANSFORM);
static_assert(static_cast<TestOperationType>(BIDIRECTIONAL_SEQUENCE_LSTM) ==
              TestOperationType::BIDIRECTIONAL_SEQUENCE_LSTM);
static_assert(static_cast<TestOperationType>(BIDIRECTIONAL_SEQUENCE_RNN) ==
              TestOperationType::BIDIRECTIONAL_SEQUENCE_RNN);
static_assert(static_cast<TestOperationType>(BOX_WITH_NMS_LIMIT) ==
              TestOperationType::BOX_WITH_NMS_LIMIT);
static_assert(static_cast<TestOperationType>(CAST) == TestOperationType::CAST);
static_assert(static_cast<TestOperationType>(CHANNEL_SHUFFLE) ==
              TestOperationType::CHANNEL_SHUFFLE);
static_assert(static_cast<TestOperationType>(DETECTION_POSTPROCESSING) ==
              TestOperationType::DETECTION_POSTPROCESSING);
static_assert(static_cast<TestOperationType>(EQUAL) == TestOperationType::EQUAL);
static_assert(static_cast<TestOperationType>(EXP) == TestOperationType::EXP);
static_assert(static_cast<TestOperationType>(EXPAND_DIMS) == TestOperationType::EXPAND_DIMS);
static_assert(static_cast<TestOperationType>(GATHER) == TestOperationType::GATHER);
static_assert(static_cast<TestOperationType>(GENERATE_PROPOSALS) ==
              TestOperationType::GENERATE_PROPOSALS);
static_assert(static_cast<TestOperationType>(GREATER) == TestOperationType::GREATER);
static_assert(static_cast<TestOperationType>(GREATER_EQUAL) == TestOperationType::GREATER_EQUAL);
static_assert(static_cast<TestOperationType>(GROUPED_CONV_2D) ==
              TestOperationType::GROUPED_CONV_2D);
static_assert(static_cast<TestOperationType>(HEATMAP_MAX_KEYPOINT) ==
              TestOperationType::HEATMAP_MAX_KEYPOINT);
static_assert(static_cast<TestOperationType>(INSTANCE_NORMALIZATION) ==
              TestOperationType::INSTANCE_NORMALIZATION);
static_assert(static_cast<TestOperationType>(LESS) == TestOperationType::LESS);
static_assert(static_cast<TestOperationType>(LESS_EQUAL) == TestOperationType::LESS_EQUAL);
static_assert(static_cast<TestOperationType>(LOG) == TestOperationType::LOG);
static_assert(static_cast<TestOperationType>(LOGICAL_AND) == TestOperationType::LOGICAL_AND);
static_assert(static_cast<TestOperationType>(LOGICAL_NOT) == TestOperationType::LOGICAL_NOT);
static_assert(static_cast<TestOperationType>(LOGICAL_OR) == TestOperationType::LOGICAL_OR);
static_assert(static_cast<TestOperationType>(LOG_SOFTMAX) == TestOperationType::LOG_SOFTMAX);
static_assert(static_cast<TestOperationType>(MAXIMUM) == TestOperationType::MAXIMUM);
static_assert(static_cast<TestOperationType>(MINIMUM) == TestOperationType::MINIMUM);
static_assert(static_cast<TestOperationType>(NEG) == TestOperationType::NEG);
static_assert(static_cast<TestOperationType>(NOT_EQUAL) == TestOperationType::NOT_EQUAL);
static_assert(static_cast<TestOperationType>(PAD_V2) == TestOperationType::PAD_V2);
static_assert(static_cast<TestOperationType>(POW) == TestOperationType::POW);
static_assert(static_cast<TestOperationType>(PRELU) == TestOperationType::PRELU);
static_assert(static_cast<TestOperationType>(QUANTIZE) == TestOperationType::QUANTIZE);
static_assert(static_cast<TestOperationType>(QUANTIZED_16BIT_LSTM) ==
              TestOperationType::QUANTIZED_16BIT_LSTM);
static_assert(static_cast<TestOperationType>(RANDOM_MULTINOMIAL) ==
              TestOperationType::RANDOM_MULTINOMIAL);
static_assert(static_cast<TestOperationType>(REDUCE_ALL) == TestOperationType::REDUCE_ALL);
static_assert(static_cast<TestOperationType>(REDUCE_ANY) == TestOperationType::REDUCE_ANY);
static_assert(static_cast<TestOperationType>(REDUCE_MAX) == TestOperationType::REDUCE_MAX);
static_assert(static_cast<TestOperationType>(REDUCE_MIN) == TestOperationType::REDUCE_MIN);
static_assert(static_cast<TestOperationType>(REDUCE_PROD) == TestOperationType::REDUCE_PROD);
static_assert(static_cast<TestOperationType>(REDUCE_SUM) == TestOperationType::REDUCE_SUM);
static_assert(static_cast<TestOperationType>(ROI_ALIGN) == TestOperationType::ROI_ALIGN);
static_assert(static_cast<TestOperationType>(ROI_POOLING) == TestOperationType::ROI_POOLING);
static_assert(static_cast<TestOperationType>(RSQRT) == TestOperationType::RSQRT);
static_assert(static_cast<TestOperationType>(SELECT) == TestOperationType::SELECT);
static_assert(static_cast<TestOperationType>(SIN) == TestOperationType::SIN);
static_assert(static_cast<TestOperationType>(SLICE) == TestOperationType::SLICE);
static_assert(static_cast<TestOperationType>(SPLIT) == TestOperationType::SPLIT);
static_assert(static_cast<TestOperationType>(SQRT) == TestOperationType::SQRT);
static_assert(static_cast<TestOperationType>(TILE) == TestOperationType::TILE);
static_assert(static_cast<TestOperationType>(TOPK_V2) == TestOperationType::TOPK_V2);
static_assert(static_cast<TestOperationType>(TRANSPOSE_CONV_2D) ==
              TestOperationType::TRANSPOSE_CONV_2D);
static_assert(static_cast<TestOperationType>(UNIDIRECTIONAL_SEQUENCE_LSTM) ==
              TestOperationType::UNIDIRECTIONAL_SEQUENCE_LSTM);
static_assert(static_cast<TestOperationType>(UNIDIRECTIONAL_SEQUENCE_RNN) ==
              TestOperationType::UNIDIRECTIONAL_SEQUENCE_RNN);
static_assert(static_cast<TestOperationType>(RESIZE_NEAREST_NEIGHBOR) ==
              TestOperationType::RESIZE_NEAREST_NEIGHBOR);
static_assert(static_cast<TestOperationType>(QUANTIZED_LSTM) == TestOperationType::QUANTIZED_LSTM);
static_assert(static_cast<TestOperationType>(IF) == TestOperationType::IF);
static_assert(static_cast<TestOperationType>(WHILE) == TestOperationType::WHILE);
static_assert(static_cast<TestOperationType>(ELU) == TestOperationType::ELU);
static_assert(static_cast<TestOperationType>(HARD_SWISH) == TestOperationType::HARD_SWISH);
static_assert(static_cast<TestOperationType>(FILL) == TestOperationType::FILL);
static_assert(static_cast<TestOperationType>(RANK) == TestOperationType::RANK);
static_assert(static_cast<TestOperationType>(BATCH_MATMUL) == TestOperationType::BATCH_MATMUL);
static_assert(static_cast<TestOperationType>(PACK) == TestOperationType::PACK);
static_assert(static_cast<TestOperationType>(MIRROR_PAD) == TestOperationType::MIRROR_PAD);
static_assert(static_cast<TestOperationType>(REVERSE) == TestOperationType::REVERSE);

static_assert(static_cast<TestOperandLifeTime>(TEMPORARY_VARIABLE) ==
              TestOperandLifeTime::TEMPORARY_VARIABLE);
static_assert(static_cast<TestOperandLifeTime>(SUBGRAPH_INPUT) ==
              TestOperandLifeTime::SUBGRAPH_INPUT);
static_assert(static_cast<TestOperandLifeTime>(SUBGRAPH_OUTPUT) ==
              TestOperandLifeTime::SUBGRAPH_OUTPUT);
static_assert(static_cast<TestOperandLifeTime>(CONSTANT_COPY) ==
              TestOperandLifeTime::CONSTANT_COPY);
static_assert(static_cast<TestOperandLifeTime>(CONSTANT_REFERENCE) ==
              TestOperandLifeTime::CONSTANT_REFERENCE);
static_assert(static_cast<TestOperandLifeTime>(NO_VALUE) == TestOperandLifeTime::NO_VALUE);
static_assert(static_cast<TestOperandLifeTime>(SUBGRAPH_LIFETIME) == TestOperandLifeTime::SUBGRAPH);

}  // anonymous namespace
}  // namespace android::nn::fuzz