/*
 * Copyright (c) 2019, Alliance for Open Media. All rights reserved
 *
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
 */

#include <assert.h>
#include <math.h>
#include <stdio.h>

#include "third_party/googletest/src/googletest/include/gtest/gtest.h"

#include "config/av1_rtcd.h"

#include "aom_ports/aom_timer.h"
#include "av1/encoder/cnn.h"
#include "av1/encoder/partition_cnn_weights.h"
#include "test/acm_random.h"
#include "test/function_equivalence_test.h"
#include "test/util.h"

#define SQR(x) ((x) * (x))

// Best possible pixelwise guarenteed preicison given each float has at most
// 3 specified decimals.
#define PIXELWISE_FLOAT_TOL 1E-2

#define MSE_FLOAT_TOL 1E-6
#define MSE_INT_TOL 0

// CNN convolve pixelwise error threshold for functional equivalence.
#define CNN_CONVOLVE_PIXELWISE_FLOAT_TOL 1E-3f

namespace {

class CNNTest : public ::testing::Test {
 protected:
  static void RunCNNTest(int image_width, int image_height, const float *input,
                         const float *expected, const CNN_CONFIG *cnn_config,
                         int in_stride, CNN_THREAD_DATA *thread_data,
                         double tolerance) {
    int out_width, out_height, out_channels;
    av1_find_cnn_output_size(image_width, image_height, cnn_config, &out_width,
                             &out_height, &out_channels);

    const int out_size = out_width * out_height;
    const int out_stride = out_width;

    float *output_ =
        (float *)aom_malloc(sizeof(*output_) * out_size * out_channels);
    ASSERT_NE(output_, nullptr);
    float *output[CNN_MAX_CHANNELS] = { nullptr };
    for (int channel = 0; channel < out_channels; ++channel) {
      output[channel] = output_ + (channel * out_size);
    }
    const int num_outputs = 1;
    const int output_chs[1] = { out_channels };
    const int output_strides[1] = { out_stride };
    CNN_MULTI_OUT output_struct = { num_outputs, output_chs, output_strides,
                                    output };

    RunMultiOutCNNTest(&input, image_width, image_height, in_stride, cnn_config,
                       thread_data, &output_struct, &expected, tolerance);

    aom_free(output_);
  }

  static void RunMultiOutCNNTest(const float **input, int image_width,
                                 int image_height, int in_stride,
                                 const CNN_CONFIG *cnn_config,
                                 CNN_THREAD_DATA *thread_data,
                                 CNN_MULTI_OUT *output, const float **expected,
                                 double tolerance) {
    const int num_outputs = output->num_outputs;
    const int *output_chs = output->output_channels;

    int *out_widths = (int *)aom_calloc(num_outputs, sizeof(*out_widths));
    int *out_heights = (int *)aom_calloc(num_outputs, sizeof(*out_heights));
    int *not_used = (int *)aom_calloc(num_outputs, sizeof(*not_used));
    ASSERT_NE(out_widths, nullptr);
    ASSERT_NE(out_heights, nullptr);
    ASSERT_NE(not_used, nullptr);

    av1_find_cnn_output_size(image_width, image_height, cnn_config, out_widths,
                             out_heights, not_used);
    av1_cnn_predict(input, image_width, image_height, in_stride, cnn_config,
                    thread_data, output);

    int channel_offset = 0;
    for (int output_idx = 0; output_idx < num_outputs; output_idx++) {
      const float *expected_out = expected[output_idx];
      const int curr_output_chs = output_chs[output_idx];
      const int out_size = out_widths[output_idx] * out_heights[output_idx];

      double mse = 0;
      int expected_ite = 0;
      for (int channel = 0; channel < curr_output_chs; ++channel) {
        const float *buf_out = output->output_buffer[channel_offset];

        for (int i = 0; i < out_size; ++i) {
          EXPECT_NEAR(expected_out[expected_ite], buf_out[i],
                      PIXELWISE_FLOAT_TOL)
              << " output " << output_idx << " channel " << channel << " pixel "
              << expected_ite % out_size << ": " << expected_out[expected_ite]
              << "/" << buf_out[i] << std::endl;
          mse += SQR(expected_out[expected_ite] - buf_out[i]);
          expected_ite++;
        }

        channel_offset++;
      }
      mse /= (out_size * curr_output_chs);
      EXPECT_LE(mse, tolerance) << " output " << output_idx << std::endl;
    }

    aom_free(out_widths);
    aom_free(out_heights);
    aom_free(not_used);
  }

  static void AssignLayerWeightsBiases(CNN_CONFIG *cnn_config, float *weights,
                                       float *bias) {
    size_t weight_offset = 0;
    size_t bias_offset = 0;
    for (int layer = 0; layer < cnn_config->num_layers; ++layer) {
      CNN_LAYER_CONFIG *layer_config = &cnn_config->layer_config[layer];
      layer_config->weights = weights + weight_offset;
      layer_config->bias = bias + bias_offset;
      weight_offset += layer_config->filter_width *
                       layer_config->filter_height * layer_config->in_channels *
                       layer_config->out_channels;
      bias_offset += layer_config->out_channels;

      ASSERT_NE(layer_config->weights, nullptr);
      ASSERT_NE(layer_config->bias, nullptr);
    }
  }
};

}  // namespace

TEST_F(CNNTest, TestMultilayerConvolution) {
  int image_height = 16;
  int image_width = 16;
  int filter_height = 5;
  int filter_width = 4;

  float input[] = {
    -3, 1,  -3, 2,  -2, -2, 2,  -2, 1,  -2, -3, 1,  2,  2,  2,  -2, 0,  1,  -1,
    -3, -1, -1, 1,  0,  -3, 1,  0,  -1, 1,  0,  0,  -3, -3, -3, 0,  2,  1,  -1,
    2,  0,  1,  -3, -1, 2,  2,  1,  -2, 0,  -1, 0,  -2, -2, -1, 1,  0,  0,  0,
    -2, -2, -2, 1,  1,  -2, 1,  1,  -2, -2, 1,  -2, -1, -2, -3, 2,  -3, -1, 1,
    0,  -2, -2, -2, 1,  -2, -2, -1, -1, 2,  2,  2,  -1, 1,  -3, -3, 0,  2,  0,
    2,  1,  -3, -3, 1,  2,  2,  1,  -2, -3, 0,  -3, 0,  -3, -2, 0,  1,  1,  0,
    -3, 2,  -1, 2,  1,  0,  1,  -2, 1,  -1, -1, 2,  0,  -2, -3, 1,  1,  -2, -1,
    -3, -3, -1, 0,  -3, -2, 0,  0,  1,  0,  -3, -2, -1, 1,  0,  2,  1,  0,  -3,
    -2, -3, -3, -1, 0,  -2, 2,  -1, -3, 0,  -1, -1, 2,  0,  -3, -2, -1, 0,  0,
    1,  -2, 1,  2,  1,  2,  2,  -3, 2,  -1, 0,  0,  -1, 0,  2,  2,  -1, 2,  -2,
    1,  1,  -3, -3, 1,  -1, -1, -2, 2,  -2, -2, 2,  -1, -3, 2,  -3, 1,  -1, -1,
    -3, 1,  -1, 1,  0,  -3, -3, 1,  -3, -3, 0,  2,  2,  -2, -1, 2,  0,  2,  1,
    -1, -3, 0,  0,  -1, -1, 1,  0,  2,  0,  -3, 2,  1,  0,  1,  -3, 2,  -3, -3,
    -1, -3, -3, 2,  0,  2,  -2, 1,  -1,
  };

  float weights[] = {
    -2, 2,  -2, 2,  -1, -3, 2,  2,  0,  0,  -3, -1, -2, -3, 1,  -1, 0,  0,  0,
    2,  -2, 2,  -2, -3, 1,  1,  1,  -3, -1, 0,  1,  2,  -2, 0,  -1, -3, -1, -2,
    2,  -3, -3, 1,  -2, -3, 0,  2,  1,  -3, -3, -1, -3, -2, -1, -3, -1, -3, -2,
    -1, -3, -1, -2, -2, -3, 2,  0,  -3, 0,  -3, -3, 1,  -3, -1, 0,  -1, 1,  1,
    -1, 1,  -2, 0,  2,  0,  -3, 1,  -1, -1, 2,  0,  1,  -3, -3, 1,  2,  -3, -3,
    1,  -3, 2,  0,  -3, 1,  2,  2,  -2, -1, -2, 1,  1,  0,  -2, -2, 1,  2,  -1,
    -3, 1,  -2, 2,  -3, -2, -3, 2,  1,  0,  -2, 0,  1,  -3, 2,  -2, -2, 0,  2,
    -3, 2,  0,  0,  1,  -2, 1,  1,  -2, -1, -2, 1,  -2, 0,  -2, -2, 0,  -1, -1,
    -3, -3, -3, 1,  -3, -2, 2,  -1, 2,  0,  2,  -2, 2,  -2, 1,  -3, -3, -1, 0,
    2,  2,  1,  -1, -3, -1, -3, 2,  1,  -2, 0,  -3, -1, -3, -1, 2,  1,  0,  2,
    -1, 1,  0,  1,  2,  -1, -2, 2,  1,  -3, -1, -3, 0,  1,  -2, 0,  -2, -3, 0,
    -2, 2,  2,  0,  0,  2,  -3, 2,  -3, -2, 1,  2,  -3, -3, -1, -3, 0,  -3, -3,
    -2, -2, -2, 0,  0,  1,  0,  0,  -1, 0,  0,  -3, 0,  -3, -1, -2, 1,  -2, -1,
    2,  -2, 0,  0,  1,  0,  -2, -1, 0,  -3, 1,  0,  -1, -3, 1,  -1, 1,  -1, -3,
    1,  0,  1,  1,  -1, 2,  2,  0,  0,  1,  -3, 2,  -2, -2, -3, -2, -1, -2, 2,
    0,  2,  -2, -3, -1, -3, 2,  2,  -1, 2,  2,  -1, 0,  -3, 1,
  };

  float bias[] = {
    1, -1, 0, 1, 1, 1, -2,
  };

  float expected_same[] = {
    -1125, 2926,  6406,  631,   -1244, 97,    -1454, 2526,  1065,  3292,  3464,
    2553,  -330,  532,   1038,  1182,  -402,  3758,  3392,  9854,  4365,  1408,
    4736,  3134,  3838,  2409,  3221,  4350,  6750,  4045,  815,   1188,  2959,
    9802,  9590,  4572,  5740,  4253,  1701,  7974,  7012,  6854,  7093,  3907,
    4539,  3886,  4267,  3505,  465,   7824,  9219,  10026, 7968,  957,   2295,
    5594,  10811, 9641,  5950,  10043, 8783,  3132,  1421,  1110,  4108,  13929,
    10660, -84,   -61,   3932,  -180,  6811,  13393, 15147, 15640, 9337,  6961,
    3808,  1604,  1398,  1047,  6739,  10144, 6517,  4698,  2678,  7389,  2595,
    5248,  12075, 11272, 13951, 8820,  1090,  2199,  2206,  2788,  12116, 6683,
    2612,  -291,  3183,  9414,  12316, 14524, 12333, 13208, 7832,  4664,  4657,
    3534,  1298,  -666,  4250,  7707,  9103,  5760,  688,   9571,  15782, 14203,
    14878, 17339, 14684, 8690,  5671,  875,   1429,  1531,  6173,  2984,  5558,
    2996,  7928,  6733,  16117, 15262, 12757, 7980,  3923,  4795,  5973,  2051,
    455,   -1922, 1816,  5906,  3321,  10908, 10910, 7377,  12204, 12809, 11195,
    7451,  6666,  74,    -1645, -35,   -391,  3813,  7324,  892,   1656,  6095,
    12193, 14648, 12156, 14663, 10251, 10325, 7821,  3925,  323,   697,   442,
    1324,  4669,  7002,  5485,  5171,  5086,  10582, 11053, 9709,  11353, 8543,
    5256,  2873,  235,   -628,  1496,  1878,  -867,  3420,  6865,  5937,  10182,
    13277, 10069, 10789, 5998,  624,   -2082, 4417,  1258,  -1080, -819,  -1430,
    1033,  5220,  6335,  8471,  8980,  11908, 14430, 12584, 8404,  1576,  -803,
    985,   1481,  1367,  -193,  873,   3684,  2288,  6676,  9477,  11155, 9602,
    9707,  10507, 4739,  3174,  -575,  -178,  3002,  1710,  423,   -477,  554,
    3088,  2029,  5113,  5000,  3771,  6090,  5365,  1185,  2855,  399,   -312,
    -1577, 176,   955,
  };

  float expected_replicate[] = {
    13768, 13528, 12999, 6906,  4618,  4043,  2611,  9955,  6685,  4776,  2753,
    1036,  3063,  4544,  5183,  7349,  12451, 12501, 9131,  12753, 8908,  4058,
    6299,  7542,  7115,  3307,  3360,  3543,  9754,  7808,  5991,  9019,  14320,
    14919, 12492, 6871,  7373,  3336,  2085,  10604, 9377,  6882,  5009,  3103,
    6220,  6278,  7588,  10196, 11045, 11563, 11842, 11911, 8279,  2030,  1858,
    6368,  12123, 9909,  6347,  10345, 9365,  4038,  1673,  3051,  16492, 16649,
    12276, 408,   -301,  4122,  -654,  7864,  14038, 15279, 15315, 9744,  8243,
    5298,  746,   380,   9824,  9124,  10895, 6640,  4712,  2669,  6980,  2759,
    5385,  12345, 11336, 13129, 8600,  2370,  3682,  5219,  12407, 13123, 6784,
    2612,  -291,  3183,  9414,  12316, 14524, 12333, 13397, 7543,  3916,  4153,
    4477,  4314,  7983,  8418,  9163,  9103,  5760,  688,   9571,  15782, 14203,
    14878, 17718, 14570, 7940,  6642,  5094,  7133,  9964,  10219, 3224,  5558,
    2996,  7928,  6733,  16117, 15262, 12757, 7958,  4401,  5187,  5476,  5529,
    6055,  2206,  3909,  6015,  3321,  10908, 10910, 7377,  12204, 12809, 11195,
    6967,  6840,  481,   -1600, 274,   1,     10373, 8514,  1123,  2117,  6758,
    12736, 16223, 13585, 15988, 11771, 10600, 7918,  4156,  2840,  3111,  3287,
    6359,  7652,  8813,  6530,  6967,  7789,  13671, 13990, 13247, 13241, 9836,
    5251,  3024,  2313,  1834,  4187,  2637,  -1312, 2139,  7378,  7665,  11933,
    15591, 15314, 15678, 9531,  2820,  -1516, 3400,  1314,  22,    363,   -2896,
    -898,  5906,  7308,  10650, 12975, 16978, 20370, 18817, 12381, 4118,  -861,
    -137,  236,   1802,  1632,  -350,  2334,  3400,  8680,  14064, 18216, 18675,
    21765, 22871, 11491, 4937,  -1555, -11,   1669,  2392,  3265,  -5254, -217,
    5001,  8063,  13444, 18884, 19706, 22794, 21064, 9545,  6689,  -7,    289,
    -2021, 504,   2347,
  };

  float expected_valid[] = {
    2612,  -291,  3183,  9414,  12316, 14524, 12333, 9103,  5760,  688,
    9571,  15782, 14203, 14878, 5558,  2996,  7928,  6733,  16117, 15262,
    12757, 3321,  10908, 10910, 7377,  12204, 12809, 11195,
  };

  CNN_CONFIG cnn_config = { 3,
                            0,
                            0,
                            0,
                            0,
                            {
                                {
                                    1,
                                    filter_width,
                                    filter_height,
                                    3,
                                    1,
                                    1,
                                    0,
                                    nullptr,
                                    nullptr,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    0,
                                    BRANCH_NO_COPY,
                                    BRANCH_NOC,
                                    {},
                                    {},
                                    -1,
                                },
                                {
                                    3,
                                    filter_width,
                                    filter_height,
                                    3,
                                    1,
                                    1,
                                    0,
                                    nullptr,
                                    nullptr,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    0,
                                    BRANCH_NO_COPY,
                                    BRANCH_NOC,
                                    {},
                                    {},
                                    -1,
                                },
                                {
                                    3,
                                    filter_width,
                                    filter_height,
                                    1,
                                    1,
                                    1,
                                    0,
                                    nullptr,
                                    nullptr,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    0,
                                    BRANCH_NO_COPY,
                                    BRANCH_NOC,
                                    {},
                                    {},
                                    0,
                                },
                            } };

  // Weights and biases need to be specified separately because
  // of the offset.
  AssignLayerWeightsBiases(&cnn_config, weights, bias);

  CNN_THREAD_DATA thread_data = { 1, NULL };

  RunCNNTest(image_width, image_height, input, expected_same, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);

  for (int i = 0; i < cnn_config.num_layers; ++i) {
    cnn_config.layer_config[i].pad = PADDING_SAME_REPLICATE;
  }

  RunCNNTest(image_width, image_height, input, expected_replicate, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);

  for (int i = 0; i < cnn_config.num_layers; ++i) {
    cnn_config.layer_config[i].pad = PADDING_VALID;
  }

  RunCNNTest(image_width, image_height, input, expected_valid, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);
}

TEST_F(CNNTest, TestRELUSingleLayer) {
  int image_width = 8;
  int image_height = 8;
  int filter_height = 5;
  int filter_width = 4;
  float input[] = {
    0, -2, -3, 1,  -1, 2,  -2, 1,  -3, -1, 0,  1,  -2, -3, -2, -2,
    1, -3, 2,  -3, -1, -1, 2,  0,  -2, -3, 0,  -2, -3, 1,  -1, -1,
    2, -2, 0,  -2, -3, -3, 1,  1,  -1, 1,  0,  1,  -3, 0,  2,  2,
    0, -3, 1,  -3, 2,  -2, 1,  -1, -1, -2, -3, -2, -1, -3, -2, -1,
  };
  float expected_same[] = {
    9,  0,  1,  1,  0,  3,  0,  19, 0,  12, 10, 0,  0,  0,  5, 0,
    0,  18, 21, 7,  19, 4,  3,  0,  0,  9,  16, 0,  11, 16, 0, 11,
    12, 2,  0,  11, 0,  16, 6,  0,  8,  22, 13, 10, 12, 0,  0, 0,
    0,  1,  2,  12, 29, 6,  10, 0,  13, 0,  0,  5,  8,  10, 0, 0,
  };
  float expected_replicate[] = {
    18, 17, 12, 2,  0,  0,  5,  11, 0,  17, 22, 6,  0,  0,  17, 0,
    0,  18, 21, 7,  19, 4,  3,  5,  3,  9,  16, 0,  11, 16, 0,  3,
    3,  2,  0,  11, 0,  16, 6,  0,  17, 22, 13, 10, 12, 0,  0,  0,
    0,  4,  1,  10, 30, 7,  10, 0,  23, 8,  0,  13, 15, 19, 8,  10,
  };
  float expected_valid[] = {
    18, 21, 7, 19, 4, 9, 16, 0, 11, 16, 2, 0, 11, 0, 16, 22, 13, 10, 12, 0,
  };
  float weights[] = {
    -2, -3, 1, 2, 2, -2, -3, 0, -3, 2, 2, -3, -3, -2, 0, 1, 2, 0, -1, -1,
  };
  float bias[] = { -3 };

  CNN_CONFIG cnn_config = { 1,
                            0,
                            0,
                            0,
                            0,
                            { {
                                1,
                                filter_width,
                                filter_height,
                                1,
                                1,
                                1,
                                0,
                                weights,
                                bias,
                                PADDING_SAME_ZERO,
                                RELU,
                                0,
                                0,
                                BRANCH_NO_COPY,
                                BRANCH_NOC,
                                {},
                                {},
                                0,
                            } } };

  CNN_THREAD_DATA thread_data = { 1, NULL };

  RunCNNTest(image_width, image_height, input, expected_same, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);

  cnn_config.layer_config[0].pad = PADDING_SAME_REPLICATE;

  RunCNNTest(image_width, image_height, input, expected_replicate, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);

  cnn_config.layer_config[0].pad = PADDING_VALID;

  RunCNNTest(image_width, image_height, input, expected_valid, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);
}

TEST_F(CNNTest, TestVaryingStridesVaryingDimImages) {
  float weights[] = {
    1,  -5, -3, -4, -1, 1,  2,  -3, 2,  2,  -1, 1,  -5, 1,  1,
    -3, -5, 3,  1,  4,  -2, -5, -2, -3, -5, 0,  -1, -5, 2,  -2,
    -2, 1,  -2, -4, 1,  3,  -2, 2,  0,  -3, 2,  -3, -2, -3,
  };
  float bias[] = { 2 };

  CNN_CONFIG cnn_config = { 1,
                            0,
                            0,
                            0,
                            0,
                            {
                                {
                                    1,
                                    4,
                                    11,
                                    1,
                                    7,
                                    6,
                                    0,
                                    weights,
                                    bias,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    0,
                                    BRANCH_NO_COPY,
                                    BRANCH_NOC,
                                    {},
                                    {},
                                    0,
                                },
                            } };

  int image_height = 24;
  int image_width = 17;
  float input[] = {
    -1, -3, 4,  4,  -5, 4,  3,  -5, -1, -3, 4,  -4, 2,  -3, 3,  -5, 2,  -1, -5,
    1,  -1, 3,  1,  -3, -3, 4,  0,  2,  -3, -5, -5, -4, 0,  -5, -2, -3, -1, -2,
    2,  -5, 4,  4,  0,  -4, -3, 1,  -3, -5, -4, -4, 1,  -2, -3, 3,  -3, -3, -1,
    -5, -5, -2, 3,  1,  -1, -5, -5, 1,  -4, -2, -1, -2, -4, -4, 2,  -2, 2,  1,
    -2, -4, -1, 1,  -2, -5, 3,  -2, -1, -1, -5, -3, 1,  -2, -2, -3, -1, -2, -4,
    -2, 1,  -4, -1, 4,  3,  -4, 0,  4,  2,  2,  4,  -3, -5, 2,  2,  1,  -1, -4,
    -2, 1,  3,  2,  0,  4,  -1, -3, 2,  1,  -4, 2,  2,  -4, -2, 0,  -2, -1, 4,
    4,  2,  3,  -4, 2,  -4, -5, 4,  -1, -3, -1, 0,  -4, 1,  3,  -1, -3, -5, 3,
    -2, -4, 1,  2,  -2, -3, -3, -5, 1,  -3, -1, 0,  -1, 3,  -4, -1, -5, -5, 1,
    0,  0,  -2, -2, 2,  -2, 0,  0,  2,  0,  -3, 0,  -1, -4, -4, -1, 3,  -4, -4,
    -1, 0,  -5, -3, -2, 4,  -3, -4, -4, 0,  -5, 1,  -2, -3, -3, -4, 4,  3,  4,
    3,  3,  -1, 3,  1,  -3, -2, 3,  3,  0,  2,  -4, -3, 2,  2,  0,  -2, 4,  -2,
    2,  -2, -1, -4, -2, 2,  -4, 3,  -1, 4,  1,  1,  4,  -1, -4, -4, 1,  1,  -2,
    4,  -1, 3,  2,  -3, 4,  3,  1,  4,  0,  -4, 2,  0,  2,  4,  -2, -2, 4,  2,
    -1, -2, 1,  -3, 2,  3,  -5, -3, 4,  4,  2,  -5, -4, -5, -2, -4, 2,  0,  2,
    -5, 4,  -4, -2, -5, 2,  1,  0,  4,  1,  -2, -3, -4, -3, -4, 3,  3,  2,  0,
    -3, 1,  -5, 4,  0,  4,  -1, 3,  -5, -5, -2, -1, -1, 4,  3,  3,  4,  3,  -4,
    4,  -3, -3, -1, -4, -1, -4, -1, -2, 4,  -2, -4, 4,  4,  -3, -4, -1, 1,  2,
    -1, -2, -2, 3,  2,  2,  -3, 0,  -1, 0,  3,  2,  -5, 0,  -4, 0,  0,  2,  -4,
    -1, -1, 0,  -2, 0,  1,  0,  0,  4,  -5, -1, -5, 2,  -1, 0,  2,  -1, 1,  3,
    -3, -5, -2, -3, 4,  -2, -2, -1, -3, -4, -1, -2, -4, 1,  4,  -3, -2, -1, 3,
    -3, -2, 3,  2,  1,  -4, -3, -5, 1,
  };
  float expected_1[] = {
    41, -26, 5, 76, 13, 83, -21, 53, -54, -14, 21, 121,
  };

  CNN_THREAD_DATA thread_data = { 1, NULL };

  RunCNNTest(image_width, image_height, input, expected_1, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);

  cnn_config.layer_config[0].skip_width = 6;
  cnn_config.layer_config[0].skip_height = 7;

  float expected_2[] = {
    21, -50, 41, 20, 72, 127, -21, 103, 62, -37, 83, -3,
  };
  RunCNNTest(image_width, image_height, input, expected_2, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);

  cnn_config.layer_config[0].skip_width = 3;
  cnn_config.layer_config[0].skip_height = 10;

  float expected_3[] = {
    -26, -21, -35, 69, 49,  4,  -51, -43, -56,
    -41, 15,  -44, 40, -62, 63, 38,  27,  47,
  };
  RunCNNTest(image_width, image_height, input, expected_3, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);

  cnn_config.layer_config[0].skip_width = 10;
  cnn_config.layer_config[0].skip_height = 3;

  float expected_4[] = {
    21, 49, 28, 87, 50, 40, 102, 81, 58, 85, 51, 66, 36, 19, -37, -45,
  };

  RunCNNTest(image_width, image_height, input, expected_4, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);
}

TEST_F(CNNTest, TestMaxPool) {
  int image_width = 8;
  int image_height = 8;
  int stride = 3;
  float input[] = {
    1,  -4, -4, 8, 0, 7, -5, -2, 8, 2, 2, 8,  5,  -1, -1, 9,
    -3, 0,  -2, 0, 6, 3, -4, 8,  7, 8, 7, -1, 4,  -1, 0,  2,
    -5, -2, 8,  5, 5, 4, 2,  7,  4, 6, 2, 8,  8,  -4, -3, -4,
    -3, -1, 2,  3, 3, 6, -5, 8,  9, 5, 0, -2, -1, 6,  5,  7,
  };

  float expected[] = {
    49, 58, 70, 68, 68, 70, 48, 57, 88,
  };

  float weights[] = {
    3, 1, 3, 4, -1, 5, -2, 1, -4,
  };

  float bias[] = {
    -3,
  };

  CNN_CONFIG cnn_config = { 1,
                            0,
                            0,
                            0,
                            0,
                            { {
                                1,
                                3,
                                3,
                                1,
                                stride,
                                stride,
                                1,
                                weights,
                                bias,
                                PADDING_SAME_ZERO,
                                NONE,
                                0,
                                0,
                                BRANCH_NO_COPY,
                                BRANCH_NOC,
                                {},
                                {},
                                0,
                            } } };

  CNN_THREAD_DATA thread_data = { 1, NULL };

  RunCNNTest(image_width, image_height, input, expected, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);
}

TEST_F(CNNTest, TestDeconvolveNonActivationSingleLayerSingleKernel) {
  int image_width = 4;
  int image_height = 7;
  float input[] = {
    9,  6,   181, 9,  218, 30, 80,  108, 68,  216, 70, 128, 179, 228,
    33, 212, 34,  14, 48,  27, 230, 23,  202, 113, 80, 56,  122, 112,
  };

  float expected_1_same[] = {
    15,   -30,  36,   -525,  377, -193, 558, 531,  6,   -24,  -15,  124,
    166,  -561, -356, -754,  -3,  -3,   -3,  -3,   -3,  -3,   -3,   -3,
    433,  -311, 711,  381,   247, -317, 453, 129,  215, -627, -409, -885,
    17,   -255, -55,  -647,  -3,  -3,   -3,  -3,   -3,  -3,   -3,   -3,
    133,  -719, 633,  -225,  785, 191,  463, 79,   65,  9,    77,   -853,
    -365, -949, -15,  -667,  -3,  -3,   -3,  -3,   -3,  -3,   -3,   -3,
    355,  -866, 990,  207,   747, 12,   520, -116, 176, -312, -133, -1370,
    -426, -802, 143,  -771,  -3,  -3,   -3,  -3,   -3,  -3,   -3,   -3,
    65,   -79,  127,  -59,   135, -90,  195, 114,  31,  -91,  -57,  -133,
    17,   -176, -72,  -276,  -3,  -3,   -3,  -3,   -3,  -3,   -3,   -3,
    457,  -302, 733,  58,    470, -475, 829, 490,  227, -670, -440, -790,
    153,  -588, -294, -1150, -3,  -3,   -3,  -3,   -3,  -3,   -3,   -3,
    157,  -251, 349,  -185,  409, -293, 587, 251,  77,  -187, -107, -369,
    7,    -481, -135, -827,  -3,  -3,   -3,  -3,   -3,  -3,   -3,   -3,
  };
  float expected_1_valid[] = {
    -30,  15,   -30,  36,   -525,  377,  -193,  558,  531,  24,   24,   6,
    6,    -24,  -15,  124,  166,   -561, -356,  -754, -21,  -39,  -3,   -3,
    -3,   -3,   -3,   -3,   -3,    -3,   -3,    -3,   -3,   -657, 433,  -311,
    711,  381,  247,  -317, 453,   129,  321,   321,  215,  215,  -627, -409,
    -885, 17,   -255, -55,  -647,  -219, -435,  -3,   -3,   -3,   -3,   -3,
    -3,   -3,   -3,   -3,   -3,    -3,   -207,  133,  -719, 633,  -225, 785,
    191,  463,  79,   381,  381,   65,   65,    9,    77,   -853, -365, -949,
    -15,  -667, -259, -515, -3,    -3,   -3,    -3,   -3,   -3,   -3,   -3,
    -3,   -3,   -3,   -540, 355,   -866, 990,   207,  747,  12,   520,  -116,
    633,  633,  176,  176,  -312,  -133, -1370, -426, -802, 143,  -771, -427,
    -851, -3,   -3,   -3,   -3,    -3,   -3,    -3,   -3,   -3,   -3,   -3,
    -105, 65,   -79,  127,  -59,   135,  -90,   195,  114,  78,   78,   31,
    31,   -91,  -57,  -133, 17,    -176, -72,   -276, -57,  -111, -3,   -3,
    -3,   -3,   -3,   -3,   -3,    -3,   -3,    -3,   -3,   -693, 457,  -302,
    733,  58,   470,  -475, 829,   490,  336,   336,  227,  227,  -670, -440,
    -790, 153,  -588, -294, -1150, -229, -455,  -3,   -3,   -3,   -3,   -3,
    -3,   -3,   -3,   -3,   -3,    -3,   -243,  157,  -251, 349,  -185, 409,
    -293, 587,  251,  333,  333,   77,   77,    -187, -107, -369, 7,    -481,
    -135, -827, -227, -451,
  };
  float weights_1[] = { -3, 2, -1, 3, 3, 1, 1, -3, -2, -4 };
  float bias_1[] = { -3 };

  CNN_CONFIG cnn_config = { 1,
                            0,
                            0,
                            0,
                            0,
                            { {
                                1,
                                5,
                                2,
                                1,
                                2,
                                3,
                                0,
                                weights_1,
                                bias_1,
                                PADDING_SAME_ZERO,
                                NONE,
                                1,
                                0,
                                BRANCH_NO_COPY,
                                BRANCH_NOC,
                                {},
                                {},
                                0,
                            } } };

  CNN_THREAD_DATA thread_data = { 1, NULL };

  RunCNNTest(image_width, image_height, input, expected_1_same, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);

  // Change padding to valid
  cnn_config.layer_config[0].pad = PADDING_VALID;

  RunCNNTest(image_width, image_height, input, expected_1_valid, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);

  float expected_12_same[] = {
    15,  -12,  6,    36,   -9,   -528, 377,  -184, 513,  558,  -12,  24,
    6,   -30,  -15,  -33,  -21,  166,  154,  -546, -356, -718, -30,  -21,
    433, -221, 561,  711,  -33,  -153, 247,  -83,  -87,  453,  -111, 321,
    215, -657, -409, -845, -93,  17,   -43,  -243, -55,  -215, -327, -219,
    133, -71,  -447, 633,  -219, 435,  785,  -73,  -177, 463,  -131, 381,
    65,  -207, 77,   -59,  -651, -365, -797, -213, -15,  -155, -387, -259,
    355, -182, -150, 990,  -231, 582,  747,  -36,  -540, 520,  -215, 633,
    176, -540, -133, -491, -687, -426, -882, -102, 143,  77,   -639, -427,
    65,  -37,  57,   127,  -17,  -105, 135,  -51,  60,   195,  -30,  78,
    31,  -105, -57,  -125, -45,  17,   -11,  -147, -72,  -168, -84,  -57,
    457, -233, 618,  733,  -26,  -540, 470,  -205, 264,  829,  -116, 336,
    227, -693, -440, -900, -72,  153,  107,  -609, -294, -698, -342, -229,
    157, -83,  69,   349,  -59,  -201, 409,  -125, 27,   587,  -115, 333,
    77,  -243, -107, -267, -171, 7,    -105, -369, -135, -379, -339, -227,
  };
  float expected_12_valid[] = {
    -30,  15,   -12,  6,    36,   -9,   -528, 377,  -184, 513,  558,  -12,
    24,   24,   6,    6,    -30,  -15,  -33,  -21,  166,  154,  -546, -356,
    -718, -30,  -21,  -39,  -657, 433,  -221, 561,  711,  -33,  -153, 247,
    -83,  -87,  453,  -111, 321,  321,  215,  215,  -657, -409, -845, -93,
    17,   -43,  -243, -55,  -215, -327, -219, -435, -207, 133,  -71,  -447,
    633,  -219, 435,  785,  -73,  -177, 463,  -131, 381,  381,  65,   65,
    -207, 77,   -59,  -651, -365, -797, -213, -15,  -155, -387, -259, -515,
    -540, 355,  -182, -150, 990,  -231, 582,  747,  -36,  -540, 520,  -215,
    633,  633,  176,  176,  -540, -133, -491, -687, -426, -882, -102, 143,
    77,   -639, -427, -851, -105, 65,   -37,  57,   127,  -17,  -105, 135,
    -51,  60,   195,  -30,  78,   78,   31,   31,   -105, -57,  -125, -45,
    17,   -11,  -147, -72,  -168, -84,  -57,  -111, -693, 457,  -233, 618,
    733,  -26,  -540, 470,  -205, 264,  829,  -116, 336,  336,  227,  227,
    -693, -440, -900, -72,  153,  107,  -609, -294, -698, -342, -229, -455,
    -243, 157,  -83,  69,   349,  -59,  -201, 409,  -125, 27,   587,  -115,
    333,  333,  77,   77,   -243, -107, -267, -171, 7,    -105, -369, -135,
    -379, -339, -227, -451,
  };

  // Change skip_width, skip_height to {2, 3}
  cnn_config.layer_config[0].skip_width = 3;
  cnn_config.layer_config[0].skip_height = 2;
  // Set padding to same
  cnn_config.layer_config[0].pad = PADDING_SAME_ZERO;

  RunCNNTest(image_width, image_height, input, expected_12_same, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);

  // Change padding to valid
  cnn_config.layer_config[0].pad = PADDING_VALID;
  RunCNNTest(image_width, image_height, input, expected_12_valid, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);

  cnn_config.layer_config[0].filter_width = 4;
  cnn_config.layer_config[0].filter_height = 3;
  float weights_2[] = { -1, -3, -1, -3, 0, 2, -2, 4, 3, 0, 1, 4 };
  float bias_2[] = { -4 };
  cnn_config.layer_config[0].weights = weights_2;
  cnn_config.layer_config[0].bias = bias_2;

  cnn_config.layer_config[0].skip_width = 5;
  cnn_config.layer_config[0].skip_height = 2;
  float expected_2_same[] = {
    -13,  -31,  -13,  -31,  -4,   -10,  -22,  -10,  -22,  -4,   -185, -547,
    -185, -547, -4,   -13,  -31,  -13,  -31,  -4,   -4,   14,   -22,  32,
    -4,   -4,   8,    -16,  20,   -4,   -4,   358,  -366, 720,  -4,   -4,
    14,   -22,  32,   -4,   -195, -658, -213, -622, -4,   -16,  -94,  -28,
    -70,  -4,   459,  -244, 97,   480,  -4,   -85,  -328, -103, -292, -4,
    -4,   432,  -440, 868,  -4,   -4,   56,   -64,  116,  -4,   -4,   156,
    -164, 316,  -4,   -4,   212,  -220, 428,  -4,   582,  -208, 146,  664,
    -4,   -130, -652, -190, -532, -4,   166,  -214, 6,    106,  -4,   192,
    -388, -24,  44,   -4,   -4,   132,  -140, 268,  -4,   -4,   428,  -436,
    860,  -4,   -4,   136,  -144, 276,  -4,   -4,   252,  -260, 508,  -4,
    21,   -541, -115, -269, -4,   416,  -688, -16,  176,  -4,   173,  -103,
    33,   177,  -4,   168,  -640, -88,  -128, -4,   -4,   354,  -362, 712,
    -4,   -4,   452,  -460, 908,  -4,   -4,   62,   -70,  128,  -4,   -4,
    420,  -428, 844,  -4,   499,  -106, 141,  610,  -4,   666,  -46,  210,
    866,  -4,   47,   -148, -19,  -16,  -4,   605,  -85,  181,  763,  -4,
    -4,   64,   -72,  132,  -4,   -4,   24,   -32,  52,   -4,   -4,   92,
    -100, 188,  -4,   -4,   50,   -58,  104,  -4,   -132, -694, -200, -558,
    -4,   15,   -73,  -13,  -17,  -4,   -62,  -610, -158, -418, -4,   -36,
    -343, -90,  -235, -4,   -4,   456,  -464, 916,  -4,   -4,   42,   -50,
    88,   -4,   -4,   400,  -408, 804,  -4,   -4,   222,  -230, 448,  -4,
    606,  -244, 146,  676,  -4,   9,    -172, -37,  -80,  -4,   480,  -370,
    76,   438,  -4,   223,  -340, -3,   112,  -4,   -4,   156,  -164, 316,
    -4,   -4,   108,  -116, 220,  -4,   -4,   240,  -248, 484,  -4,   -4,
    220,  -228, 444,  -4,
  };
  float expected_2_valid[] = {
    -13,  -31,  -13,  -31,  -4,   -10,  -22,  -10,  -22,  -4,   -185, -547,
    -185, -547, -4,   -13,  -31,  -13,  -31,  -4,   14,   -22,  32,   -4,
    -4,   8,    -16,  20,   -4,   -4,   358,  -366, 720,  -4,   -4,   14,
    -22,  32,   -195, -658, -213, -622, -4,   -16,  -94,  -28,  -70,  -4,
    459,  -244, 97,   480,  -4,   -85,  -328, -103, -292, -4,   432,  -440,
    868,  -4,   -4,   56,   -64,  116,  -4,   -4,   156,  -164, 316,  -4,
    -4,   212,  -220, 428,  582,  -208, 146,  664,  -4,   -130, -652, -190,
    -532, -4,   166,  -214, 6,    106,  -4,   192,  -388, -24,  44,   -4,
    132,  -140, 268,  -4,   -4,   428,  -436, 860,  -4,   -4,   136,  -144,
    276,  -4,   -4,   252,  -260, 508,  21,   -541, -115, -269, -4,   416,
    -688, -16,  176,  -4,   173,  -103, 33,   177,  -4,   168,  -640, -88,
    -128, -4,   354,  -362, 712,  -4,   -4,   452,  -460, 908,  -4,   -4,
    62,   -70,  128,  -4,   -4,   420,  -428, 844,  499,  -106, 141,  610,
    -4,   666,  -46,  210,  866,  -4,   47,   -148, -19,  -16,  -4,   605,
    -85,  181,  763,  -4,   64,   -72,  132,  -4,   -4,   24,   -32,  52,
    -4,   -4,   92,   -100, 188,  -4,   -4,   50,   -58,  104,  -132, -694,
    -200, -558, -4,   15,   -73,  -13,  -17,  -4,   -62,  -610, -158, -418,
    -4,   -36,  -343, -90,  -235, -4,   456,  -464, 916,  -4,   -4,   42,
    -50,  88,   -4,   -4,   400,  -408, 804,  -4,   -4,   222,  -230, 448,
    606,  -244, 146,  676,  -4,   9,    -172, -37,  -80,  -4,   480,  -370,
    76,   438,  -4,   223,  -340, -3,   112,  -4,   156,  -164, 316,  -4,
    -4,   108,  -116, 220,  -4,   -4,   240,  -248, 484,  -4,   -4,   220,
    -228, 444,  236,  -4,   76,   316,  -4,   164,  -4,   52,   220,  -4,
    362,  -4,   118,  484,  -4,   332,  -4,   108,  444,
  };
  // Set padding to same
  cnn_config.layer_config[0].pad = PADDING_SAME_ZERO;

  RunCNNTest(image_width, image_height, input, expected_2_same, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);

  cnn_config.layer_config[0].pad = PADDING_VALID;

  RunCNNTest(image_width, image_height, input, expected_2_valid, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);

  cnn_config.layer_config[0].skip_width = 2;
  cnn_config.layer_config[0].skip_height = 5;
  float expected_21_same[] = {
    -31,  -19,  -49,   -191, -565, -194, -574, -13,  14,   -22,  44,   -16,
    382,  -366, 738,   -22,  -4,   23,   32,   545,  20,   204,  720,  5,
    -4,   -4,   -4,    -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,
    -4,   -4,   -4,    -4,   -658, -252, -748, -114, -334, -192, -568, -112,
    432,  -440, 928,   -64,  276,  -164, 532,  -220, -4,   304,  868,  266,
    116,  400,  316,   104,  -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,
    -4,   -4,   -4,    -4,   -4,   -4,   -4,   -4,   -208, -288, -856, -290,
    -862, -202, -598,  -132, 132,  -140, 700,  -436, 1000, -144, 532,  -260,
    -4,   712,  268,   422,  860,  450,  276,  124,  -4,   -4,   -4,   -4,
    -4,   -4,   -4,    -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,
    -541, -411, -1225, -265, -787, -249, -739, -216, 354,  -362, 1168, -460,
    974,  -70,  552,   -428, -4,   859,  712,  323,  908,  665,  128,  208,
    -4,   -4,   -4,    -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,
    -4,   -4,   -4,    -4,   -106, -52,  -148, -66,  -190, -79,  -229, -31,
    64,   -72,  160,   -32,  148,  -100, 242,  -58,  -4,   72,   132,  154,
    52,   125,  188,   23,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,
    -4,   -4,   -4,    -4,   -4,   -4,   -4,   -4,   -694, -257, -763, -229,
    -679, -319, -949,  -117, 456,  -464, 962,  -50,  492,  -408, 1030, -230,
    -4,   295,  916,   625,  88,   537,  804,  109,  -4,   -4,   -4,   -4,
    -4,   -4,   -4,    -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,
    -244, -140, -412,  -182, -538, -238, -706, -116, 156,  -164, 428,  -116,
    464,  -248, 708,   -228, -4,   244,  316,  418,  220,  454,  484,  108,
    -4,   -4,   -4,    -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,
    -4,   -4,   -4,    -4,
  };
  float expected_21_valid[] = {
    -13,  -31,  -19,  -49,  -191, -565, -194, -574, -13,  -31,   -4,   14,
    -22,  44,   -16,  382,  -366, 738,  -22,  32,   23,   -4,    23,   32,
    545,  20,   204,  720,  5,    32,   -4,   -4,   -4,   -4,    -4,   -4,
    -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,    -4,   -4,
    -4,   -4,   -222, -658, -252, -748, -114, -334, -192, -568,  -112, -328,
    -4,   432,  -440, 928,  -64,  276,  -164, 532,  -220, 428,   650,  -4,
    304,  868,  266,  116,  400,  316,  104,  428,  -4,   -4,    -4,   -4,
    -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,    -4,   -4,
    -4,   -4,   -4,   -4,   -72,  -208, -288, -856, -290, -862,  -202, -598,
    -132, -388, -4,   132,  -140, 700,  -436, 1000, -144, 532,   -260, 508,
    200,  -4,   712,  268,  422,  860,  450,  276,  124,  508,   -4,   -4,
    -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,    -4,   -4,
    -4,   -4,   -4,   -4,   -4,   -4,   -183, -541, -411, -1225, -265, -787,
    -249, -739, -216, -640, -4,   354,  -362, 1168, -460, 974,   -70,  552,
    -428, 844,  533,  -4,   859,  712,  323,  908,  665,  128,   208,  844,
    -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,    -4,   -4,
    -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -38,  -106,  -52,  -148,
    -66,  -190, -79,  -229, -31,  -85,  -4,   64,   -72,  160,   -32,  148,
    -100, 242,  -58,  104,  98,   -4,   72,   132,  154,  52,    125,  188,
    23,   104,  -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,    -4,   -4,
    -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,    -234, -694,
    -257, -763, -229, -679, -319, -949, -117, -343, -4,   456,   -464, 962,
    -50,  492,  -408, 1030, -230, 448,  686,  -4,   295,  916,   625,  88,
    537,  804,  109,  448,  -4,   -4,   -4,   -4,   -4,   -4,    -4,   -4,
    -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,    -4,   -4,
    -84,  -244, -140, -412, -182, -538, -238, -706, -116, -340,  -4,   156,
    -164, 428,  -116, 464,  -248, 708,  -228, 444,  236,  -4,    244,  316,
    418,  220,  454,  484,  108,  444,
  };

  cnn_config.layer_config[0].pad = PADDING_SAME_ZERO;

  RunCNNTest(image_width, image_height, input, expected_21_same, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);

  cnn_config.layer_config[0].pad = PADDING_VALID;

  RunCNNTest(image_width, image_height, input, expected_21_valid, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);
}

TEST_F(CNNTest, TestLargeKernelsAndStrides) {
  float input_10x11[] = {
    4,  4,  2,  4,  2,  -5, -2, 3, -1, 0,  0,  1,  2,  0,  -5, -2, -5, 1,  -3,
    -1, 4,  -3, 2,  -2, 1,  0,  1, -3, -3, -4, -2, -2, 1,  -4, -1, 4,  1,  -4,
    -4, -4, 3,  2,  -5, 3,  -5, 1, 2,  -4, 1,  -1, 3,  4,  -2, 3,  -3, 3,  0,
    2,  -4, -5, -5, -2, -1, -2, 1, 1,  1,  -2, 4,  -5, 4,  -1, -1, 2,  3,  -4,
    2,  2,  3,  0,  0,  1,  0,  3, 2,  3,  1,  -2, 3,  -4, 3,  2,  4,  -2, 0,
    4,  -4, 1,  -3, -3, -3, -5, 1, -3, -5, 0,  4,  -1, -3, 2,
  };

  float weights_10x11[] = {
    -3, 4,  -4, -3, -5, 1,  -2, 3,  1,  -4, -4, 0,  -1, 0,  3,  1,  -3, -2, 0,
    -1, 1,  3,  -4, -4, -3, -3, -2, 4,  3,  -5, 4,  2,  -3, 4,  -2, -1, 2,  -1,
    -5, 0,  -3, 0,  3,  -5, -5, 3,  -4, -1, -5, 3,  4,  0,  4,  -5, 2,  -1, 2,
    -1, -1, -1, -5, 0,  -4, 3,  -1, 1,  1,  -1, 3,  2,  -5, -4, 0,  -4, 4,  -5,
    -3, 4,  -5, 2,  -5, -4, -4, -1, 3,  3,  0,  2,  -4, 1,  -2, 1,  1,  0,  3,
    -2, 0,  1,  2,  4,  -3, -1, -5, -5, 2,  -4, 1,  1,  2,  -4, -2, -2, 2,  1,
    3,  4,  -5, 1,  -1, -3, -3, -1, -2, -5, 1,  -1, 0,  1,  4,  4,  0,  0,  4,
    -3, -1, -5, -3, 0,  1,  1,  1,  -5, 3,  4,  3,  -5, 3,  -2, -2, 0,  -4, 0,
    0,  -2, 1,  -4, -1, 0,  -5, -2, -2, -5, -3, -3, 1,  1,  -3, 2,  4,  2,  4,
    -4, -3, 3,  1,  1,  3,  -4, 4,  -2, -3, -3, -3, -3, -4, -2, 3,  -5, 2,  4,
    -1, -4, -4, 4,  -2, -1, 3,  -3, -4, -4, -2, 4,  1,  0,  2,  -1, 4,  -3, 1,
    4,  -3, 4,  4,  0,  -4, 3,  -2, -3, 2,  3,  -1, -3, 2,  1,  4,  -2, -3, 1,
    4,  -2, 2,  -2, -5, -2, 1,  4,  -1, -4, 4,  -5, 2,  -5, -4, -1, -2, 3,  1,
    2,  1,  -5, 1,  -5, -4, -1, -2, 2,  -2, -4, -3, -2, -2, 4,  -1, 2,  2,  -4,
    2,  -2, 4,  -4, -2, -2, 1,  -1, 1,  1,  1,  -4, -5, -2, 3,  -4, -1, 3,  -2,
    3,  2,  -5, -4, 0,  3,  -2, -4, -5, 3,  -2, -4, 2,  -2, 1,  -4, 0,  2,  -5,
    1,  -4, -1, -1, 4,  -5, -4, 0,  -5, -4, -3, -5, -4, 0,  2,  0,  -4, 2,  -2,
    1,  1,  -3, 2,  0,  -4, 0,  -4, 1,  0,  -5, -1, -1, -1, -5, 4,  2,  2,  -4,
    3,  -2, -2, 2,  -3, -2, -1, 2,  -4, -5, 2,  -2, -4, -5, -5, -1, 2,  -1, 0,
    -5, -2, -2, -5, 0,  1,  -1, -5, 0,  3,  2,  3,  0,  -3, -2, 0,  -5, -1, -2,
    2,  -4, -1, 2,  2,  -5, 2,  -4, 0,  3,  -3, 1,  0,  0,  1,  -5, -3, 1,  -1,
    0,  -4, -3, 2,  -4, -4, 4,  -1, 0,  1,  2,  -4, -5, 4,  -2, 1,  -4, -4, -3,
    -1, -1, 1,  -1, -4, -1, -4, -3, 2,  -1, -2, -4, 1,  1,  0,  -2, 0,  -4, 3,
    -3, 0,  -4, -1, -4, 2,  -1, -2, -5, -1, -2, -3, 3,  -1, 0,  -3, 0,  1,  -5,
    1,  -5, 0,  1,
  };

  float bias_10x11[] = { 3 };

  float expected_10x11[] = {
    118,
  };

  CNN_CONFIG cnn_config = { 1,
                            0,
                            0,
                            0,
                            0,
                            { {
                                1,
                                23,
                                20,
                                1,
                                15,
                                20,
                                0,
                                weights_10x11,
                                bias_10x11,
                                PADDING_SAME_ZERO,
                                NONE,
                                0,
                                0,
                                BRANCH_NO_COPY,
                                BRANCH_NOC,
                                {},
                                {},
                                0,
                            } } };

  int image_height = 10;
  int image_width = 11;

  CNN_THREAD_DATA thread_data = { 1, NULL };

  RunCNNTest(image_width, image_height, input_10x11, expected_10x11,
             &cnn_config, image_width, &thread_data, MSE_INT_TOL);

  float input_11x10[] = {
    -2, -2, 3,  -5, -1, -3, 1,  3,  2,  1,  1,  -5, 4,  1,  3,  -5, 3,  -3, -5,
    0,  -1, -3, -3, 1,  1,  -5, -1, -5, -5, -3, 0,  1,  -3, -1, -3, -3, 0,  3,
    4,  -4, -1, 3,  -3, -1, -3, 1,  -3, -2, -1, -4, -3, 2,  -4, 1,  -4, -1, -3,
    -5, -1, 2,  3,  0,  2,  2,  -5, 4,  1,  2,  -1, -4, 4,  -4, -4, 0,  -1, 1,
    -1, 1,  -3, -3, -2, 1,  2,  4,  4,  4,  -3, -3, 0,  1,  0,  1,  4,  1,  3,
    4,  -3, -2, -4, 4,  2,  0,  3,  4,  -1, 2,  -2, 1,  -3, -2,
  };

  float weights_11x10[] = {
    4,  -1, 1,  -1, 2,  4,  3,  3,  -4, 3,  -5, 1,  -1, -1, -2, -2, 0,  2,  -3,
    -2, 3,  -5, -1, 0,  -1, -2, -2, -1, 2,  4,  3,  1,  0,  0,  -3, 3,  -4, -1,
    -5, 4,  -2, -2, 1,  2,  -1, -3, 1,  2,  -5, 1,  -3, 3,  3,  0,  -4, -4, -5,
    -3, -4, -4, 4,  -2, 4,  4,  -2, 2,  -5, -1, -2, -5, -1, 4,  -3, 3,  -2, 0,
    -4, -3, 0,  -1, -2, 4,  2,  0,  -2, -5, -4, 1,  4,  -4, -2, 2,  -2, 1,  1,
    -4, 1,  -4, -4, -2, 4,  2,  -1, -5, -5, 1,  -3, -3, 3,  -3, -5, -3, 4,  -1,
    -1, -3, 0,  -4, 3,  -1, 0,  -2, 0,  -5, -2, -5, 2,  0,  -5, 2,  3,  -2, 2,
    4,  -1, 1,  -3, 2,  3,  2,  0,  -5, -4, -5, 2,  1,  1,  -1, -2, 3,  4,  2,
    -2, 4,  -2, 3,  1,  -4, -3, -1, 4,  4,  -3, -5, -2, 2,  0,  3,  -2, 3,  -1,
    -4, 0,  -2, 0,  3,  4,  -2, -3, -2, 0,  3,  4,  2,  -4, 0,  1,  2,  2,  -1,
    -1, 4,  1,  4,  -2, -1, -1, -5, 1,  -3, 3,  3,  -1, -4, 3,  -5, 0,  0,  -1,
    -4, -1, -2, 4,  -2, 3,  3,  -3, 1,  -1, 2,  -1, 4,  4,  -2, -2, 4,  -2, 0,
    3,  -3, -5, -1, -2, 4,  -4, 2,  -4, 0,  -2, 3,  -3, 2,  2,  -2, -5, -1, 4,
    3,  -2, -1, 3,  3,  -1, 3,  0,  -3, 0,  4,  2,  0,  -1, 4,  1,  1,  2,  1,
    3,  1,  1,  1,  -3, -5, -4, 4,  -4, 2,  0,  0,  -4, 1,  4,  -5, 4,  4,  0,
    1,  0,  -2, -4, -4, -3, 0,  1,  -5, 4,  0,  -3, -2, -4, 2,  4,  1,  -5, 1,
    -4, 1,  0,  -3, -3, 0,  2,  -5, 4,  3,  -2, -5, 3,  1,  -1, 0,  3,  -2, -2,
    3,  -2, -5, 4,  1,  -2, 2,  -1, 0,  4,  0,  -5, 3,  -2, 1,  2,  1,  -5, -3,
    -2, -5, 4,  -4, 0,  3,  2,  -1, -4, -1, 2,  1,  -2, 3,  -1, -4, 2,  0,  -3,
    1,  -1, 2,  -5, -4, -1, -5, 1,  4,  3,  4,  2,  -3, 1,  -5, -1, 3,  0,  -1,
    -4, 3,  4,  -5, 4,  4,  -3, 2,  -3, -1, -3, -5, -3, 2,  -3, -2, 1,  1,  0,
    -5, 3,  2,  1,  -5, 1,  1,  1,  3,  4,  -4, -1, -2, 0,  -5, -3, -5, -2, -4,
    3,  3,  3,  4,  0,  -4, -1, -5, 0,  -3, 1,  4,  4,  -4, 4,  -5, -5, -1, -2,
    -5, 3,  -4, 4,  3,  0,  -3, 2,  -2, 0,  0,  4,  4,  0,  -2, 1,  -1, -3, 2,
    -1, 1,  -3, -5,
  };

  float bias_11x10[] = {
    -5,
  };

  float expected_11x10[] = {
    36,  -84,  95,   45,  18,   46,   77,  -54, -99,  -149, 66,  49,  161, 11,
    39,  61,   -66,  61,  4,    -3,   34,  -44, -23,  31,   64,  29,  47,  72,
    -27, -27,  121,  -3,  100,  1,    30,  -78, -12,  -89,  -59, 8,   -16, 112,
    91,  -102, -26,  -4,  30,   54,   4,   -84, -24,  -58,  27,  -53, -33, 5,
    53,  -26,  63,   50,  -103, -130, -23, 6,   -104, -207, 73,  23,  77,  132,
    38,  32,   -130, -44, -60,  7,    27,  176, 45,   -32,  -2,  99,  -97, 63,
    69,  126,  47,   63,  136,  -57,  5,   16,  -40,  -157, 8,   38,  -44, -10,
    91,  7,    122,  140, 30,   -105, 4,   -1,  113,  64,   180, 141,
  };

  cnn_config.layer_config[0].weights = weights_11x10;
  cnn_config.layer_config[0].bias = bias_11x10;
  cnn_config.layer_config[0].filter_width = 20;
  cnn_config.layer_config[0].filter_height = 23;
  cnn_config.layer_config[0].skip_width = 1;
  cnn_config.layer_config[0].skip_height = 1;
  image_height = 11;
  image_width = 10;

  RunCNNTest(image_width, image_height, input_11x10, expected_11x10,
             &cnn_config, image_width, &thread_data, MSE_INT_TOL);
}

TEST_F(CNNTest, TestSoftsignSingleLayer) {
  int image_width = 8;
  int image_height = 8;
  int filter_height = 5;
  int filter_width = 4;
  float input[] = {
    -0.5220f, 0.8410f,  -0.8990f, -0.0090f, 0.6710f,  -0.9470f, -0.8240f,
    -0.0870f, 0.5380f,  0.4750f,  0.570f,   -0.3760f, -0.6960f, -0.5940f,
    -0.3830f, 0.080f,   -0.0980f, -0.4940f, -0.4030f, 0.9460f,  -0.6020f,
    0.4220f,  0.6190f,  0.6640f,  -0.9210f, -0.1470f, -0.2480f, -0.1120f,
    -0.580f,  -0.0650f, 0.3330f,  0.9860f,  -0.7430f, 0.7610f,  0.4840f,
    0.1030f,  0.9570f,  0.6120f,  -0.5240f, -0.1220f, -0.5850f, -0.270f,
    0.7840f,  -0.9790f, 0.7290f,  -0.30f,   -0.6460f, 0.0780f,  0.4750f,
    -0.0510f, 0.4550f,  0.3850f,  -0.7230f, 0.4460f,  -0.6260f, -0.810f,
    0.8720f,  -0.2120f, -0.580f,  -0.9510f, -0.8430f, -0.1340f, -0.0850f,
    0.9190f,
  };
  float expected_same[] = {
    0.430f,   0.660f,  0.5510f,  -0.610f,  0.450f,  -0.1610f, 0.0520f,  0.3240f,
    0.6820f,  0.3820f, 0.6360f,  0.7480f,  0.3080f, 0.090f,   0.3910f,  0.1730f,
    0.340f,   0.6660f, -0.4990f, 0.4280f,  0.1540f, 0.120f,   0.4670f,  0.6150f,
    -0.3880f, 0.7590f, 0.4190f,  0.7350f,  0.5310f, -0.5160f, -0.1760f, 0.6790f,
    -0.6780f, 0.5470f, 0.5750f,  -0.6420f, 0.7210f, -0.4620f, 0.5430f,  0.770f,
    -0.1990f, 0.3950f, 0.7860f,  -0.4380f, 0.7540f, 0.2640f,  -0.6430f, 0.4510f,
    -0.1260f, 0.1590f, -0.2110f, -0.0560f, 0.6570f, 0.680f,   0.5870f,  0.4720f,
    0.4040f,  0.3630f, 0.670f,   0.2360f,  0.410f,  0.6980f,  -0.5350f, 0.3940f,
  };
  float expected_replicate[] = {
    0.540f,   0.7230f,  -0.3530f, -0.2130f, 0.7440f,  -0.4470f, -0.6260f,
    -0.2050f, 0.7230f,  0.4630f,  0.5920f,  0.7440f,  0.6080f,  0.3130f,
    -0.5670f, -0.4720f, 0.5480f,  0.6660f,  -0.4990f, 0.4280f,  0.1540f,
    0.120f,   0.3390f,  0.6090f,  0.4160f,  0.7590f,  0.4190f,  0.7350f,
    0.5310f,  -0.5160f, -0.490f,  0.4450f,  -0.610f,  0.5470f,  0.5750f,
    -0.6420f, 0.7210f,  -0.4620f, 0.3150f,  0.7370f,  -0.5820f, 0.3950f,
    0.7860f,  -0.4380f, 0.7540f,  0.2640f,  -0.7430f, -0.5340f, -0.6270f,
    0.4430f,  0.4730f,  0.4570f,  0.7450f,  0.630f,   0.2620f,  0.3140f,
    -0.1840f, 0.1810f,  0.7210f,  0.2760f,  0.6430f,  0.6720f,  -0.4390f,
    0.2040f,
  };
  float expected_valid[] = {
    0.6660f,  -0.4990f, 0.4280f,  0.1540f,  0.120f,  0.7590f,  0.4190f,
    0.7350f,  0.5310f,  -0.5160f, 0.5470f,  0.5750f, -0.6420f, 0.7210f,
    -0.4620f, 0.3950f,  0.7860f,  -0.4380f, 0.7540f, 0.2640f,
  };
  float weights[] = {
    0.6210f,  0.3710f,  -0.2770f, -0.7230f, -0.2450f, 0.6770f,  0.3080f,
    -0.9880f, -0.080f,  0.7190f,  -0.6760f, -0.0170f, -0.8970f, 0.8260f,
    0.7390f,  -0.4550f, -0.4260f, -0.6330f, 0.0880f,  -0.9390f,
  };
  float bias[] = {
    0.750f,
  };

  CNN_CONFIG cnn_config = { 1,
                            0,
                            0,
                            0,
                            0,
                            { {
                                1,
                                filter_width,
                                filter_height,
                                1,
                                1,
                                1,
                                0,
                                weights,
                                bias,
                                PADDING_SAME_ZERO,
                                SOFTSIGN,
                                0,
                                0,
                                BRANCH_NO_COPY,
                                BRANCH_NOC,
                                {},
                                {},
                                0,
                            } } };

  CNN_THREAD_DATA thread_data = { 1, NULL };

  RunCNNTest(image_width, image_height, input, expected_same, &cnn_config,
             image_width, &thread_data, MSE_FLOAT_TOL);

  cnn_config.layer_config[0].pad = PADDING_SAME_REPLICATE;

  RunCNNTest(image_width, image_height, input, expected_replicate, &cnn_config,
             image_width, &thread_data, MSE_FLOAT_TOL);

  cnn_config.layer_config[0].pad = PADDING_VALID;

  RunCNNTest(image_width, image_height, input, expected_valid, &cnn_config,
             image_width, &thread_data, MSE_FLOAT_TOL);
}

TEST_F(CNNTest, TestBranchTensorAdd) {
  int filter_width = 2;
  int filter_height = 3;

  int image_width = 4;
  int image_height = 4;

  float input[] = {
    -3, -2, -2, 0, -1, 3, 2, -2, 1, 3, 4, 0, 2, -5, -4, 0,
  };

  float weights[] = {
    -3, -1, 4,  -1, -3, 3,  3,  0,  2,  0,  3,  2,  4,  4, 4,  -5, 1, -4,
    2,  -4, 1,  -3, 0,  4,  -5, 4,  0,  -4, -3, -1, 0,  0, -2, 0,  0, 2,
    -5, -1, 1,  -3, 3,  4,  3,  0,  1,  -1, 1,  1,  2,  4, -2, -5, 2, -2,
    3,  -2, 4,  -1, 0,  2,  3,  2,  -2, -1, -3, 1,  3,  4, -1, -3, 0, -4,
    4,  2,  -3, -3, -1, 0,  1,  0,  3,  3,  -3, 0,  3,  2, -5, -3, 4, -5,
    3,  -1, -1, -3, 0,  1,  -1, -4, 2,  4,  -1, 4,  -1, 1, 3,  4,  4, 4,
    0,  -1, -3, -3, -3, -3, 2,  -3, -2, 2,  3,  -3,
  };

  float bias[] = {
    3, 4, -1, -1, 2, 1, -2, 1, 4, 1, 3,
  };

  float expected[] = {
    -11502, -4101, -3424, 668,   -17950, -5470, -5504, 626,
    4835,   446,   1779,  -3483, 3679,   -4214, 4578,  -105,
  };

  int channels = 2;

  CNN_CONFIG cnn_config = { 6,
                            0,
                            0,
                            0,
                            0,
                            { {
                                  1,
                                  filter_width,
                                  filter_height,
                                  channels,
                                  1,
                                  1,
                                  0,
                                  weights,
                                  bias,
                                  PADDING_SAME_ZERO,
                                  NONE,
                                  0,
                                  0,
                                  BRANCH_NO_COPY,
                                  BRANCH_NOC,
                                  {},
                                  {},
                                  -1,
                              },
                              {
                                  channels,
                                  filter_width,
                                  filter_height,
                                  channels,
                                  1,
                                  1,
                                  0,
                                  nullptr,
                                  nullptr,
                                  PADDING_SAME_ZERO,
                                  NONE,
                                  0,
                                  0,
                                  BRANCH_INPUT,
                                  BRANCH_NOC,
                                  {
                                      0x02,
                                      0,
                                      0x00,
                                  },
                                  {},
                                  -1,
                              },
                              {
                                  channels,
                                  filter_width,
                                  filter_height,
                                  channels,
                                  1,
                                  1,
                                  0,
                                  nullptr,
                                  nullptr,
                                  PADDING_SAME_ZERO,
                                  NONE,
                                  0,
                                  1,
                                  BRANCH_NO_COPY,
                                  BRANCH_NOC,
                                  {},
                                  {},
                                  -1,
                              },
                              {
                                  channels,
                                  filter_width,
                                  filter_height,
                                  channels,
                                  1,
                                  1,
                                  0,
                                  nullptr,
                                  nullptr,
                                  PADDING_SAME_ZERO,
                                  NONE,
                                  0,
                                  1,
                                  BRANCH_NO_COPY,
                                  BRANCH_NOC,
                                  {},
                                  {},
                                  -1,
                              },
                              {
                                  channels,
                                  filter_width,
                                  filter_height,
                                  channels,
                                  1,
                                  1,
                                  0,
                                  nullptr,
                                  nullptr,
                                  PADDING_SAME_ZERO,
                                  NONE,
                                  0,
                                  0,
                                  BRANCH_NO_COPY,
                                  BRANCH_ADD,
                                  {
                                      0x00,
                                      0,
                                      0x02,
                                  },
                                  {},
                                  -1,
                              },
                              {
                                  channels,
                                  filter_width,
                                  filter_height,
                                  1,
                                  1,
                                  1,
                                  0,
                                  nullptr,
                                  nullptr,
                                  PADDING_SAME_ZERO,
                                  NONE,
                                  0,
                                  0,
                                  BRANCH_NO_COPY,
                                  BRANCH_NOC,
                                  {},
                                  {},
                                  0,
                              } } };

  // Weights and biases need to be specified separately because
  // of the offset.
  AssignLayerWeightsBiases(&cnn_config, weights, bias);

  CNN_THREAD_DATA thread_data = { 1, NULL };

  RunCNNTest(image_width, image_height, input, expected, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);
}

TEST_F(CNNTest, TestBranchTensorConcatenation) {
  int filter_width = 2;
  int filter_height = 3;

  int image_width = 4;
  int image_height = 4;

  float input[] = {
    -3, -2, -2, 0, -1, 3, 2, -2, 1, 3, 4, 0, 2, -5, -4, 0,
  };

  float weights[] = {
    3,  0,  2,  0,  2,  3,  1,  -3, 1,  -5, -3, 0,  -4, 4,  0,  -5, 0,  -5, -1,
    -2, -5, 0,  -3, 2,  -4, 2,  0,  2,  -1, 0,  -4, 3,  0,  0,  -1, -5, 2,  -1,
    4,  -4, -2, -3, -3, 3,  4,  -2, -1, -4, -1, 4,  4,  -1, 4,  3,  -4, 2,  -2,
    -4, -3, -2, 3,  -3, -5, -1, 3,  -2, 4,  1,  -4, -3, -5, -5, -3, 4,  -2, -2,
    -1, -5, -5, 0,  -1, -2, -3, 3,  -4, -5, 2,  -3, 1,  0,  -5, 2,  2,  -2, 0,
    2,  2,  -2, 4,  2,  2,  0,  1,  -5, -3, 0,  2,  -2, 1,  2,  -5, 2,  3,  3,
    -1, 3,  0,  -3, 3,  -4, -4, 3,  3,  -4, -2, 2,  -2, 2,  -2, -1, 3,  0,
  };

  float bias[] = {
    -3, -5, 4, -4, -3, -2, 0, 3, -4, 4, -3,
  };

  float expected[] = {
    -33533, -32087, -6741,  -2124, 39979, 41453, 14034, 689,
    -22611, -42203, -14882, -239,  15781, 15963, 9524,  837,
  };

  int channels = 2;

  CNN_CONFIG cnn_config = { 6,
                            0,
                            0,
                            0,
                            0,
                            { {
                                  1,
                                  filter_width,
                                  filter_height,
                                  channels,
                                  1,
                                  1,
                                  0,
                                  weights,
                                  bias,
                                  PADDING_SAME_ZERO,
                                  NONE,
                                  0,
                                  0,
                                  BRANCH_NO_COPY,
                                  BRANCH_NOC,
                                  {},
                                  {},
                                  -1,
                              },
                              {
                                  channels,
                                  filter_width,
                                  filter_height,
                                  channels,
                                  1,
                                  1,
                                  0,
                                  nullptr,
                                  nullptr,
                                  PADDING_SAME_ZERO,
                                  NONE,
                                  0,
                                  0,
                                  BRANCH_INPUT,
                                  BRANCH_NOC,
                                  {
                                      0x02,
                                      0,
                                      0x00,
                                  },
                                  {},
                                  -1,
                              },
                              {
                                  channels,
                                  filter_width,
                                  filter_height,
                                  channels,
                                  1,
                                  1,
                                  0,
                                  nullptr,
                                  nullptr,
                                  PADDING_SAME_ZERO,
                                  NONE,
                                  0,
                                  1,
                                  BRANCH_NO_COPY,
                                  BRANCH_NOC,
                                  {},
                                  {},
                                  -1,
                              },
                              {
                                  channels,
                                  filter_width,
                                  filter_height,
                                  channels,
                                  1,
                                  1,
                                  0,
                                  nullptr,
                                  nullptr,
                                  PADDING_SAME_ZERO,
                                  NONE,
                                  0,
                                  1,
                                  BRANCH_NO_COPY,
                                  BRANCH_NOC,
                                  {},
                                  {},
                                  -1,
                              },
                              {
                                  channels,
                                  filter_width,
                                  filter_height,
                                  channels,
                                  1,
                                  1,
                                  0,
                                  nullptr,
                                  nullptr,
                                  PADDING_SAME_ZERO,
                                  NONE,
                                  0,
                                  0,
                                  BRANCH_NO_COPY,
                                  BRANCH_CAT,
                                  {
                                      0x00,
                                      0,
                                      0x02,
                                  },
                                  {},
                                  -1,
                              },
                              {
                                  channels + channels,
                                  filter_width,
                                  filter_height,
                                  1,
                                  1,
                                  1,
                                  0,
                                  nullptr,
                                  nullptr,
                                  PADDING_SAME_ZERO,
                                  NONE,
                                  0,
                                  0,
                                  BRANCH_NO_COPY,
                                  BRANCH_NOC,
                                  {},
                                  {},
                                  0,
                              } } };

  // Weights and biases need to be specified separately because
  // of the offset.
  AssignLayerWeightsBiases(&cnn_config, weights, bias);

  CNN_THREAD_DATA thread_data = { 1, NULL };

  RunCNNTest(image_width, image_height, input, expected, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);
}

// TODO(logangw): Add test to test all combinations of branch_copy_type.

TEST_F(CNNTest, TestBranchCombinations) {
  int filter_width = 2;
  int filter_height = 3;

  int image_width = 4;
  int image_height = 4;

  float input[] = {
    3, 2, -5, -4, 4, -2, -4, -3, 4, 2, -3, 2, -3, 1, -5, -1,
  };

  float weights[] = {
    2,  3,  0,  4,  4,  3,  1,  0,  1,  -5, 4,  -3, 3,  0,  4,  -1, -1, -5,
    2,  1,  -3, -5, 3,  -1, -3, -2, 0,  -2, 3,  0,  -2, -4, -2, -2, 2,  -5,
    4,  -5, 0,  1,  -5, -4, -3, -4, 2,  -2, 1,  0,  3,  -2, -4, 3,  4,  -4,
    -1, -1, -3, -2, -2, -1, 2,  0,  2,  -1, 2,  -4, -4, -1, 2,  0,  3,  -2,
    -2, 3,  -3, 4,  -2, 4,  3,  4,  1,  0,  -2, -3, -5, 1,  -3, 2,  0,  -2,
    -2, -1, -1, -5, -2, -3, -1, 3,  3,  4,  4,  0,  2,  1,  3,  -3, 2,  -5,
    -5, 1,  -5, -1, 3,  3,  2,  -4, -1, 3,  -4, -2, -5, -2, 1,  3,  2,  2,
    -5, -2, -3, -1, -2, -4, -1, -2, 2,  1,  -4, -4, 2,  0,  2,  0,  2,  -3,
    -2, -4, 4,  0,  1,  -3, -5, 4,  -1, 2,  3,  -5, -1, 0,  4,  -1, -1, 3,
    -1, -3, 3,  1,  4,  3,  4,  3,  -4, -5, -1, 3,  3,  -4, 3,  1,  3,  -5,
    3,  4,  -5, 4,  2,  -1, -5, 2,  1,  0,  4,  0,  -3, 2,  0,  2,  -2, 1,
    -1, -2, -1, -5, 4,  3,  3,  -2, 2,  4,  -5, -5, -3, -2, 4,  0,  -4, 1,
  };

  float bias[] = {
    -1, 4, 0, 2, 2, -2, 0, -4, -5, -1, 1, -2, 3, 0, 4, -2, 1, 0, 0,
  };

  float expected[] = {
    149496, 15553,  -24193, -20956, 134094, 86432,  -68283, -6366,
    -53031, 133739, 67407,  -13539, -53205, -58635, -20033, 1979,
  };

  int channels = 2;

  CNN_CONFIG cnn_config = { 10,
                            0,
                            0,
                            0,
                            0,
                            {
                                {
                                    1,
                                    filter_width,
                                    filter_height,
                                    channels,
                                    1,
                                    1,
                                    0,
                                    weights,
                                    bias,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    0,
                                    BRANCH_NO_COPY,
                                    BRANCH_NOC,
                                    {},
                                    {},
                                    -1,
                                },
                                {
                                    channels,
                                    filter_width,
                                    filter_height,
                                    channels,
                                    1,
                                    1,
                                    0,
                                    nullptr,
                                    nullptr,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    0,
                                    BRANCH_INPUT,
                                    BRANCH_NOC,
                                    {
                                        0x06,
                                        0,
                                        0x00,
                                    },
                                    {},
                                    -1,
                                },
                                {
                                    channels,
                                    filter_width,
                                    filter_height,
                                    channels,
                                    1,
                                    1,
                                    0,
                                    nullptr,
                                    nullptr,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    2,
                                    BRANCH_OUTPUT,
                                    BRANCH_NOC,
                                    {
                                        0x08,
                                        0,
                                        0x00,
                                    },
                                    {},
                                    -1,
                                },
                                {
                                    channels,
                                    filter_width,
                                    filter_height,
                                    channels,
                                    1,
                                    1,
                                    0,
                                    nullptr,
                                    nullptr,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    3,
                                    BRANCH_NO_COPY,
                                    BRANCH_NOC,
                                    {},
                                    {},
                                    -1,
                                },
                                {
                                    channels,
                                    filter_width,
                                    filter_height,
                                    channels,
                                    1,
                                    1,
                                    0,
                                    nullptr,
                                    nullptr,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    2,
                                    BRANCH_NO_COPY,
                                    BRANCH_ADD,
                                    {
                                        0x00,
                                        0,
                                        0x08,
                                    },
                                    {},
                                    -1,
                                },
                                {
                                    channels,
                                    filter_width,
                                    filter_height,
                                    channels,
                                    1,
                                    1,
                                    0,
                                    nullptr,
                                    nullptr,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    2,
                                    BRANCH_NO_COPY,
                                    BRANCH_NOC,
                                    {},
                                    {},
                                    -1,
                                },
                                {
                                    channels,
                                    filter_width,
                                    filter_height,
                                    channels,
                                    1,
                                    1,
                                    0,
                                    nullptr,
                                    nullptr,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    1,
                                    BRANCH_NO_COPY,
                                    BRANCH_NOC,
                                    {},
                                    {},
                                    -1,
                                },
                                {
                                    channels,
                                    filter_width,
                                    filter_height,
                                    channels,
                                    1,
                                    1,
                                    0,
                                    nullptr,
                                    nullptr,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    1,
                                    BRANCH_NO_COPY,
                                    BRANCH_ADD,
                                    {
                                        0x00,
                                        0,
                                        0x0C,
                                    },
                                    {},
                                    -1,
                                },
                                {
                                    channels,
                                    filter_width,
                                    filter_height,
                                    channels,
                                    1,
                                    1,
                                    0,
                                    nullptr,
                                    nullptr,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    0,
                                    BRANCH_NO_COPY,
                                    BRANCH_ADD,
                                    {
                                        0x00,
                                        0,
                                        0x02,
                                    },
                                    {},
                                    -1,
                                },
                                {
                                    channels,
                                    filter_width,
                                    filter_height,
                                    1,
                                    1,
                                    1,
                                    0,
                                    nullptr,
                                    nullptr,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    0,
                                    BRANCH_NO_COPY,
                                    BRANCH_NOC,
                                    {},
                                    {},
                                    0,
                                },
                            } };

  // Weights and biases need to be specified separately because
  // of the offset.
  AssignLayerWeightsBiases(&cnn_config, weights, bias);

  CNN_THREAD_DATA thread_data = { 1, NULL };

  RunCNNTest(image_width, image_height, input, expected, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);
}

TEST_F(CNNTest, TestSplittingTensors) {
  int filter_width = 2;
  int filter_height = 3;

  int image_width = 4;
  int image_height = 4;

  float input[] = {
    -1, -1, 2, 1, 3, 2, 4, -3, -4, -2, 2, -3, 1, -3, 4, -2,
  };

  float weights[] = {
    -4, 1,  0,  2,  3,  4,  4,  -4, -5, -3, 2,  2,  -4, -3, 3,  2,
    4,  -4, -3, -4, -4, 1,  -3, -5, -3, 4,  2,  -2, 2,  -1, -4, -1,
    -2, -3, 1,  1,  0,  -5, -1, 3,  3,  -5, -3, 0,  -3, 1,  -3, -1,
    1,  -3, -2, -2, 4,  -2, 0,  1,  2,  2,  -4, 2,  4,  0,  -5, -2,
    4,  4,  -5, 1,  0,  2,  -2, -5, -5, -3, -5, -5, 4,  -3, 0,  0,
    -4, -4, 0,  -5, -4, 0,  0,  -3, -5, -3, -1, 2,  -1, 4,  -1, 2,
  };

  float bias[] = {
    -4, -2, -3, -3, 3, 1, -2,
  };

  float expected[] = {
    530,  -762,  1469, 777,  849,   -771, -1698, 600,
    -658, -1821, 98,   -668, -1798, 30,   887,   -971,
  };

  CNN_CONFIG cnn_config = { 3,
                            0,
                            0,
                            0,
                            0,
                            {
                                {
                                    1,
                                    filter_width,
                                    filter_height,
                                    4,
                                    1,
                                    1,
                                    0,
                                    nullptr,
                                    nullptr,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    0,
                                    BRANCH_OUTPUT,
                                    BRANCH_NOC,
                                    {
                                        0x02,
                                        2,
                                        0x00,
                                    },
                                    {},
                                    -1,
                                },
                                {
                                    4,
                                    filter_width,
                                    filter_height,
                                    2,
                                    1,
                                    1,
                                    0,
                                    nullptr,
                                    nullptr,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    0,
                                    BRANCH_NO_COPY,
                                    BRANCH_CAT,
                                    {
                                        0x00,
                                        0,
                                        0x02,
                                    },
                                    {},
                                    -1,
                                },
                                {
                                    4,
                                    filter_width,
                                    filter_height,
                                    1,
                                    1,
                                    1,
                                    0,
                                    nullptr,
                                    nullptr,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    0,
                                    BRANCH_NO_COPY,
                                    BRANCH_NOC,
                                    {},
                                    {},
                                    0,
                                },
                            } };

  // Weights and biases need to be specified separately because
  // of the offset.
  AssignLayerWeightsBiases(&cnn_config, weights, bias);

  CNN_THREAD_DATA thread_data = { 1, NULL };

  RunCNNTest(image_width, image_height, input, expected, &cnn_config,
             image_width, &thread_data, MSE_INT_TOL);
}

TEST_F(CNNTest, TestOutputChannelsCount) {
  int filter_width = 1;
  int filter_height = 1;

  int image_width = 2;
  int image_height = 2;

  float input[] = { 0, 0, 0, 0 };

  float weights[] = { 0, 0, 0, 0, 0, 0, 0, 0 };

  float bias[] = { 0, 0, 0, 0, 0, 0 };

  float expected[] = {
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  };

  CNN_CONFIG cnn_config = { 3,
                            0,
                            0,
                            0,
                            0,
                            {
                                {
                                    1,
                                    filter_width,
                                    filter_height,
                                    2,
                                    1,
                                    1,
                                    0,
                                    weights,
                                    bias,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    0,
                                    BRANCH_INPUT,
                                    BRANCH_NOC,
                                    {
                                        0x06,
                                        0,
                                        0x00,
                                    },
                                    {},
                                    -1,
                                },
                                {
                                    1,
                                    filter_width,
                                    filter_height,
                                    2,
                                    1,
                                    1,
                                    0,
                                    weights,
                                    bias,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    2,
                                    BRANCH_NO_COPY,
                                    BRANCH_CAT,
                                    {
                                        0x00,
                                        0,
                                        0x03,
                                    },
                                    {},
                                    -1,
                                },
                                {
                                    2,
                                    filter_width,
                                    filter_height,
                                    2,
                                    1,
                                    1,
                                    0,
                                    weights,
                                    bias,
                                    PADDING_SAME_ZERO,
                                    NONE,
                                    0,
                                    0,
                                    BRANCH_NO_COPY,
                                    BRANCH_CAT,
                                    {
                                        0x00,
                                        0,
                                        0x04,
                                    },
                                    {},
                                    0,
                                },
                            } };

  // Weights and biases need to be specified separately because
  // of the offset.
  AssignLayerWeightsBiases(&cnn_config, weights, bias);

  CNN_THREAD_DATA thread_data = { 1, NULL };

  RunCNNTest(image_width, image_height, input, expected, &cnn_config,
             image_width, &thread_data, MSE_FLOAT_TOL);
}

TEST_F(CNNTest, TestBatchNorm) {
  int image_width = 28;
  int image_height = 28;
  int filter_height = 7;
  int filter_width = 7;
  float input[] = {
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0117647f,  0.0705882f,  0.0705882f,  0.0705882f,
    0.494118f,  0.533333f,  0.686275f,   0.101961f,   0.65098f,    1.0f,
    0.968627f,  0.498039f,  0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.117647f,   0.141176f,   0.368627f,   0.603922f,
    0.666667f,  0.992157f,  0.992157f,   0.992157f,   0.992157f,   0.992157f,
    0.882353f,  0.67451f,   0.992157f,   0.94902f,    0.764706f,   0.25098f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.192157f,
    0.933333f,  0.992157f,  0.992157f,   0.992157f,   0.992157f,   0.992157f,
    0.992157f,  0.992157f,  0.992157f,   0.984314f,   0.364706f,   0.321569f,
    0.321569f,  0.219608f,  0.152941f,   0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0705882f,  0.858824f,   0.992157f,
    0.992157f,  0.992157f,  0.992157f,   0.992157f,   0.776471f,   0.713725f,
    0.968627f,  0.945098f,  0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.313725f,   0.611765f,   0.419608f,   0.992157f,
    0.992157f,  0.803922f,  0.0431373f,  0.0f,        0.168627f,   0.603922f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.054902f,  0.00392157f, 0.603922f,   0.992157f,   0.352941f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.545098f,  0.992157f,   0.745098f,   0.00784314f, 0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0431373f,
    0.745098f,  0.992157f,  0.27451f,    0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.137255f,   0.945098f,
    0.882353f,  0.627451f,  0.423529f,   0.00392157f, 0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.317647f,   0.941176f,   0.992157f,
    0.992157f,  0.466667f,  0.0980392f,  0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.176471f,   0.729412f,   0.992157f,   0.992157f,
    0.588235f,  0.105882f,  0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0627451f, 0.364706f,   0.988235f,   0.992157f,   0.733333f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.976471f,  0.992157f,   0.976471f,   0.25098f,    0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.180392f,   0.509804f,   0.717647f,   0.992157f,
    0.992157f,  0.811765f,  0.00784314f, 0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.152941f,   0.580392f,
    0.898039f,  0.992157f,  0.992157f,   0.992157f,   0.980392f,   0.713725f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0941176f, 0.447059f,  0.866667f,   0.992157f,   0.992157f,   0.992157f,
    0.992157f,  0.788235f,  0.305882f,   0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0901961f,  0.258824f,   0.835294f,   0.992157f,
    0.992157f,  0.992157f,  0.992157f,   0.776471f,   0.317647f,   0.00784314f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0705882f,  0.670588f,
    0.858824f,  0.992157f,  0.992157f,   0.992157f,   0.992157f,   0.764706f,
    0.313725f,  0.0352941f, 0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.215686f,  0.67451f,   0.886275f,   0.992157f,   0.992157f,   0.992157f,
    0.992157f,  0.956863f,  0.521569f,   0.0431373f,  0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.533333f,   0.992157f,
    0.992157f,  0.992157f,  0.831373f,   0.529412f,   0.517647f,   0.0627451f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f,        0.0f,        0.0f,
    0.0f,       0.0f,       0.0f,        0.0f
  };
  float expected[] = {
    -0.836424f, -0.857365f, -1.62739f,  -1.62739f,  -0.836424f, 5.40742f,
    0.920853f,  -0.692567f, -0.836424f, -0.534405f, -1.62739f,  -0.836424f,
    1.32602f,   1.36312f,   0.112766f,  -0.836424f, -0.192962f, 1.56975f,
    2.45777f,   0.944414f,  -0.192962f, -1.5519f,   -1.5519f,   -0.554006f,
    -0.192962f, 1.4231f,    -1.5519f,   -0.192962f, 1.3661f,    -1.5519f,
    -1.5519f,   -0.192962f, -0.843708f, -0.359025f, -0.843708f, -0.843708f,
    -0.843708f, 4.53065f,   0.0429584f, -0.796804f, -0.843708f, 0.3473f,
    -0.843708f, -0.843708f, -0.114439f, 3.14817f,   0.0811934f, -0.843708f
  };
  float kernel[] = {
    0.119643f,    -0.237864f,   0.0462892f,   0.0502297f,   -0.0134528f,
    0.146347f,    0.153133f,    0.0513307f,   0.0752369f,   0.0135557f,
    -0.111434f,   0.0941854f,   0.0788362f,   0.0299412f,   0.111762f,
    0.144066f,    0.00431504f,  -0.0177954f,  0.0738092f,   -0.0344215f,
    0.0832582f,   0.053989f,    -0.112691f,   0.0962145f,   0.0186525f,
    -0.00660205f, -0.111962f,   -0.126801f,   -0.231625f,   0.17309f,
    0.0748875f,   -0.179569f,   -0.00513812f, -0.156579f,   -0.147322f,
    0.184168f,    0.189308f,    -0.200359f,   -0.0156733f,  0.140649f,
    0.0858496f,   -0.0263217f,  -0.0740749f,  -0.112563f,   0.107528f,
    0.0609729f,   -0.221625f,   0.0769944f,   -0.00900815f, -0.00136441f,
    -0.0236521f,  -0.0418025f,  -0.00286299f, 0.12241f,     0.0964093f,
    -0.0150897f,  0.0532171f,   0.0625916f,   0.116939f,    0.118024f,
    0.161918f,    -0.00909767f, 0.100897f,    -0.054563f,   -0.175179f,
    -0.0687892f,  0.00734235f,  0.109833f,    -0.113776f,   0.0595405f,
    -0.170255f,   0.0124815f,   -0.0363301f,  -0.0127038f,  0.0445554f,
    -0.0729894f,  0.107428f,    -0.0341417f,  0.132619f,    0.00984557f,
    -0.00443654f, 0.202929f,    0.0945134f,   0.0148725f,   0.00998574f,
    -0.0226449f,  0.0478197f,   -0.0793442f,  0.0707599f,   -0.084225f,
    0.0865795f,   0.071104f,    -0.047894f,   0.0838322f,   0.0635493f,
    -0.00370265f, -0.157247f,   -0.0289622f,  -0.0590963f,  0.13207f,
    0.00468011f,  -0.0345372f,  0.217939f,    0.18861f,     -0.0290393f,
    -0.0440664f,  0.0126197f,   -0.129132f,   -0.124943f,   0.0968156f,
    -0.0853643f,  -0.182305f,   0.00461618f,  -0.147095f,   -0.230282f,
    0.00856019f,  0.0278893f,   -0.0300229f,  0.0417871f,   0.0804717f,
    -0.0768571f,  -0.0397085f,  -0.0601096f,  0.100901f,    -0.0184926f,
    0.0350673f,   0.0971094f,   -0.0171837f,  -0.289644f,   -0.0899041f,
    0.08998f,     -0.160319f,   -0.0195103f,  0.0392167f,   -0.137864f,
    -0.0136294f,  0.0330886f,   -0.0409244f,  -0.092533f,   -0.0427934f,
    -0.191144f,   -0.0969461f,  0.112035f,    0.138611f,    0.128717f,
    0.191184f,    0.197462f
  };
  float bias[] = { 0.186703f, 0.204358f, -0.0230452f };

  float bn_gamma[] = { 1.32173f, 1.26171f, 1.21966f };
  float bn_beta[] = { -0.232595f, -0.222652f, -0.232209f };
  float bn_mean[] = { 0.329233f, 0.199894f, 0.12389f };
  float bn_std[] = { 0.311986f, 0.189737f, 0.247104f };

  CNN_BATCHNORM_PARAMS bn_params = {
    bn_gamma,
    bn_beta,
    bn_mean,
    bn_std,
  };

  CNN_CONFIG cnn_config = {
    1,
    0,
    0,
    0,
    0,
    {
        {
            1,
            filter_width,
            filter_height,
            3,
            7,
            7,
            0,
            kernel,
            bias,
            PADDING_VALID,
            RELU,
            0,
            0,
            BRANCH_NO_COPY,
            BRANCH_NOC,
            {},
            bn_params,
            0,
        },
    },
  };

  CNN_THREAD_DATA thread_data = { 1, NULL };

  RunCNNTest(image_width, image_height, input, expected, &cnn_config,
             image_width, &thread_data, MSE_FLOAT_TOL);
}

TEST_F(CNNTest, TestMultithreading) {
  int image_height = 2;
  int image_width = 2;
  int filter_height = 3;
  int filter_width = 3;

  float input[] = {
    -2,
    4,
    1,
    0,
  };

  float weights[] = {
    -4, 2, -2, 0,  -4, 4, -3, -3, -3, -1, 1,  0,  -5, -3, 0, -5, 0, 0,
    -1, 0, 2,  -5, 0,  1, 4,  2,  1,  0,  -2, -1, -5, -3, 2, -2, 1, -5,
  };

  float bias[] = {
    -4,
    -3,
    -2,
    3,
  };

  float expected[] = {
    2, 10, -8, -17, -24, 5, -15, 6, -5, -5, 7, -10, 4, 13, 9, -14,
  };

  CNN_CONFIG cnn_config = {
    1,
    0,
    0,
    0,
    0,
    {
        {
            1,
            filter_width,
            filter_height,
            4,
            1,
            1,
            0,
            weights,
            bias,
            PADDING_SAME_ZERO,
            NONE,
            0,
            0,
            BRANCH_NO_COPY,
            BRANCH_NOC,
            {},
            {},
            0,
        },
    },
  };

  CNN_THREAD_DATA thread_data = { 1, NULL };

  RunCNNTest(image_width, image_height, input, expected, &cnn_config,
             image_width, &thread_data, MSE_FLOAT_TOL);

  const AVxWorkerInterface *const winterface = aom_get_worker_interface();
  AVxWorker workers[4];

  for (int i = 0; i < 4; ++i) {
    winterface->init(&workers[i]);
  }

  thread_data = { 4, workers };

  RunCNNTest(image_width, image_height, input, expected, &cnn_config,
             image_width, &thread_data, MSE_FLOAT_TOL);

  for (int i = 0; i < 4; ++i) {
    winterface->end(&workers[i]);
  }
}

TEST_F(CNNTest, TestMultiOutput) {
  const int image_dim = 8;
  const int image_ch = 3;
  const int filter_dim = 2;
  const int stride = 2;
  const int num_filters = 2;

  const float input_[] = {
    1.7537929121f,     0.134331551012f,    0.123580039877f,   0.957731845246f,
    0.391006834217f,   1.00699352042f,     -0.778177955829f,  -0.814166433059f,
    -0.656374394915f,  0.321967305228f,    -2.19455719176f,   0.708035038966f,
    0.409148822266f,   -0.318254408902f,   0.152450211189f,   -0.250210793369f,
    0.826811563186f,   1.6804156584f,      0.273626975978f,   0.437936241887f,
    -0.329935520167f,  -0.288761611645f,   0.156937008304f,   0.271054157295f,
    -0.0224828854332f, 1.70110336895f,     -0.989066699309f,  1.30863131729f,
    -0.165813705702f,  0.00380178619265f,  -0.0837342367587f, 0.760954783156f,
    -0.413610373524f,  1.17968204175f,     0.720295719536f,   0.308718974472f,
    -1.10091337671f,   0.693160033687f,    -0.0202862320697f, 1.0221927503f,
    -1.24521801881f,   -0.478501952308f,   -1.71648619442f,   -0.182571723636f,
    0.339292649504f,   2.0806519131f,      0.967974033444f,   0.175248672328f,
    0.0658124561472f,  0.795504169496f,    0.750592557361f,   -1.46631013249f,
    -1.79052846838f,   -1.03672179515f,    -0.841985521653f,  1.20995011489f,
    0.140859718215f,   -0.651552622661f,   0.451065110806f,   1.1189443693f,
    0.100213260593f,   -0.834076868118f,   -1.28734321611f,   1.22064420095f,
    -0.364143084361f,  0.750961509335f,    -0.888689074553f,  -0.8253547106f,
    -1.21800999027f,   -0.966670603566f,   1.37384014741f,    0.47281264834f,
    -0.420416235531f,  0.520163906493f,    0.501296589423f,   1.53418976951f,
    0.715234751485f,   0.644551588907f,    0.0763504863375f,  -0.0018541943723f,
    0.322853189656f,   -0.795099723224f,   -0.125177096675f,  1.4476577471f,
    -0.585888410088f,  -1.44391754955f,    -0.610543221933f,  -0.221859179799f,
    0.252060200774f,   -0.86287169623f,    -0.0350246229157f, 1.0932311997f,
    0.899464648842f,   -0.468806951704f,   -0.300861137168f,  1.15776414206f,
    1.03268544738f,    -0.171579585622f,   -0.179136557119f,  -0.354091003368f,
    -0.612298249394f,  -1.20237379258f,    1.54604109659f,    0.130664370287f,
    0.885225111868f,   1.0362799581f,      0.980561720868f,   -0.619379186999f,
    -1.33818929924f,   -0.237233737961f,   -1.89335425073f,   0.567821011321f,
    0.862420368465f,   -1.37380916821f,    0.352190056666f,   0.611261516274f,
    0.393237747152f,   0.894686247967f,    0.190405182149f,   0.264872662911f,
    -0.0657009133797f, 0.0580512653493f,   -0.401825294366f,  0.4106081318f,
    0.49484512188f,    -0.0751103149442f,  -1.43243736382f,   1.79855656009f,
    -1.1075351975f,    0.000354882733011f, -0.950716438608f,  1.27129831688f,
    1.00495189838f,    0.110358656713f,    1.08315032822f,    -0.972676676218f,
    -0.0757668962831f, 1.88932045165f,     -0.0672638136275f, 0.425913010161f,
    -0.781540372017f,  0.976000248609f,    0.687218504122f,   1.31374513445f,
    -0.932658930672f,  -1.25339468479f,    0.422071294078f,   -0.24189927912f,
    0.216906604642f,   -1.88720997548f,    1.99252872889f,    0.353943735777f,
    0.737434784132f,   -1.17848645017f,    1.70424254896f,    0.775297112968f,
    -0.516392797501f,  0.398130609129f,    0.737248101457f,   0.166282500886f,
    1.24699015468f,    0.47116183125f,     1.19091180182f,    -0.372695424578f,
    0.219773209389f,   -0.829467838962f,   -0.52533122724f,   1.98707754595f,
    0.553692606972f,   -0.933228902369f,   1.55427751643f,    -1.08813399144f,
    -0.325686682094f,  0.205091443796f,    -1.70381666435f,   0.466465327942f,
    1.73126863447f,    -0.939133672634f,   1.48318077459f,    -0.599414038168f,
    -1.1583078687f,    0.518116190201f,    0.133571482458f,   0.84958342672f,
    1.02205000597f,    -0.0772082009087f,  -1.69567503859f,   1.4697939436f,
    1.67813743122f,    -0.627911582938f,   0.131380509137f,   -1.35717850726f,
  };
  const float *input[3] = { input_, &input_[image_dim * image_dim],
                            &input_[2 * image_dim * image_dim] };

  const float bias[] = { 0.0f, 0.0f };

  const float weights_1[] = {
    -0.489547413618f, 0.141916424749f,  -0.279286485585f,  -0.115322211094f,
    0.299572786936f,  0.205289980785f,  -0.536254480088f,  -0.253626313744f,
    -0.422883815849f, -0.169702966298f, -0.540104704793f,  0.495319646763f,
    0.298799079422f,  -0.10054550901f,  -0.306085047056f,  0.171061886165f,
    -0.108058703878f, -0.410734629888f, -0.0640674673049f, -0.386524840979f,
    -0.157203423678f, -0.362138920529f, -0.216206085209f,  0.147502517971f,
  };

  const float weights_2[] = {
    0.207580604357f,  0.480821146263f,  -0.29111909562f,   0.47422567493f,
    0.206892553253f,  -0.235067084092f, 0.354516800602f,   -0.212399370252f,
    -0.419071343731f, -0.050350731631f, -0.0516457320279f, -0.0359310500731f,
    0.567044864811f,  -0.060341127522f, 0.0501464839637f,  -0.437785677916f,
  };

  const float weights_3[] = {
    -0.0690452401448f, -0.356657338763f,   -0.219464031809f, 0.551288365843f,
    0.181372090853f,   -0.00245268542109f, 0.409000696276f,  -0.593209108763f,
    0.587352566749f,   -0.243720660227f,   0.266232713887f,  -0.00439285245097f,
    0.252883228305f,   0.152646192631f,    0.0918944932026f, 0.398853715057f,
  };

  const float weights_4[] = {
    0.207560791573f,   0.194201350401f,   0.227802322443f,  0.206533663345f,
    0.0557331066805f,  0.0224159800424f,  -0.143939197467f, -0.27703361602f,
    0.130643888389f,   -0.269456557461f,  0.186242862864f,  -0.162879944774f,
    -0.145503996718f,  -0.0768822987581f, -0.203127976359f, -0.238119922873f,
    -0.258806479994f,  0.0357957680385f,  -0.1027606976f,   -0.287920082345f,
    0.189047820993f,   0.250711538481f,   -0.272815714175f, -0.0431449742024f,
    0.207261230996f,   -0.0396472677451f, 0.131236557412f,  0.174291832499f,
    -0.251515885765f,  -0.107164007499f,  0.185824534748f,  -0.00561585838161f,
    0.273393799578f,   -0.139563699075f,  -0.263922456031f, -0.118859844081f,
    0.109230982597f,   -0.170170294794f,  0.0123025648515f, -0.0839368964355f,
    -0.0774058234297f, 0.255847138286f,   -0.208430879637f, 0.279170114319f,
    -0.272890330712f,  -0.217725903006f,  -0.295923275459f, -0.17008723953f,
    -0.284281803405f,  0.281406323629f,   0.266910044663f,  -0.209963914338f,
    0.271980962964f,   0.142013581699f,   -0.143896509026f, -0.290509242975f,
    -0.305768180935f,  0.196902832117f,   -0.090424189662f, -0.147460802346f,
    0.217722016651f,   0.12353848977f,    -0.169177363577f, -0.0454230918512f,
  };

  const float expected_0[] = {
    -2.04858441055f,  -2.12883075791f,    -0.045177363807f, 0.763949675768f,
    -0.544361512821f, -1.58123168032f,    1.89319847039f,   0.16859080901f,
    -1.16023321135f,  -0.396988107751f,   1.76637090744f,   -1.40434786514f,
    0.908227575669f,  0.817064817605f,    0.215631134908f,  -0.848605613428f,
    -0.106756747018f, 0.0193027166685f,   0.801345615113f,  -0.395407237598f,
    -1.79983795658f,  -1.73054496242f,    0.0584392594454f, -0.388786095569f,
    -0.237269619354f, 0.000843578271263f, -1.24043512104f,  0.487839445893f,
    -0.394259726605f, 0.559632843424f,    -0.527224052291f, -1.53792340282f,
  };

  const float expected_1[] = {
    0.0f, 0.0f,           0.0f, 0.0f, 0.4057888292f, 0.325309571755f,
    0.0f, 1.22013465602f,
  };

  const float expected_2[] = {
    0.156119444687f,
    0.517385299817f,
  };

  const float expected_3[] = {
    0.224177852984f,
    0.503384419034f,
    0.156119444687f,
    0.517385299817f,
  };

  const float *expected[] = { expected_0, expected_1, expected_2, expected_3 };

  CNN_CONFIG cnn_config = {
    4,  // num_layers
    0,  // is_residue
    0,  // ext_width
    0,  // ext_height
    0,  // strict_bounds
    {
        // layer_config
        {
            image_ch,           // in_channels
            filter_dim,         // filter_width
            filter_dim,         // filter_height
            num_filters,        // out_channels
            stride,             // skip_width
            stride,             // skip_height
            0,                  // max_pool
            weights_1,          // weights
            bias,               // bias
            PADDING_SAME_ZERO,  // pad
            NONE,               // activation
            0,                  // deconvolve
            0,                  // branch
            BRANCH_OUTPUT,      // branch_copy_type
            BRANCH_NOC,         // branch_combine_type
            { 2, 0, 0 },        // branch_config
            {},                 // bn_params
            0,                  // output_num
        },
        {
            num_filters,        // in_channels
            filter_dim,         // filter_width
            filter_dim,         // filter_height
            num_filters,        // out_channels
            stride,             // skip_width
            stride,             // skip_height
            0,                  // max_pool
            weights_2,          // weights
            bias,               // bias
            PADDING_SAME_ZERO,  // pad
            RELU,               // activation
            0,                  // deconvolve
            0,                  // branch
            BRANCH_NO_COPY,     // branch_copy_type
            BRANCH_NOC,         // branch_combine_type
            {},                 // branch_config
            {},                 // bn_params
            1,                  // output_num
        },
        {
            num_filters,        // in_channels
            filter_dim,         // filter_width
            filter_dim,         // filter_height
            num_filters,        // out_channels
            stride,             // skip_width
            stride,             // skip_height
            0,                  // max_pool
            weights_3,          // weights
            bias,               // bias
            PADDING_SAME_ZERO,  // pad
            RELU,               // activation
            0,                  // deconvolve
            0,                  // branch
            BRANCH_NO_COPY,     // branch_copy_type
            BRANCH_NOC,         // branch_combine_type
            {},                 // branch_config
            {},                 // bn_params
            2,                  // output_num
        },
        {
            num_filters,     // in_channels
            2 * filter_dim,  // filter_width
            2 * filter_dim,  // filter_height
            num_filters,     // out_channels
            2 * stride,      // skip_width
            2 * stride,      // skip_height
            0,               // max_pool
            weights_4,       // weights
            bias,            // bias
            PADDING_VALID,   // pad
            RELU,            // activation
            0,               // deconvolve
            1,               // branch
            BRANCH_NO_COPY,  // branch_copy_type
            BRANCH_CAT,      // branch_combine_type
            { 0, 0, 1 },     // branch_config
            {},              // bn_params
            3,               // output_num
        },
    },
  };

  CNN_THREAD_DATA thread_data = { 1, NULL };

  const int num_outputs = 4;
  const int output_chs[4] = { filter_dim, filter_dim, filter_dim,
                              2 * filter_dim };
  const int output_dims[4] = { 4, 2, 1, 1 };
  const int output_sizes[4] = {
    output_chs[0] * output_dims[0] * output_dims[0],
    output_chs[1] * output_dims[1] * output_dims[1],
    output_chs[2] * output_dims[2] * output_dims[2],
    output_chs[3] * output_dims[3] * output_dims[3],
  };
  float *const output_ = (float *)aom_malloc(
      sizeof(*output_) *
      (output_sizes[0] + output_sizes[1] + output_sizes[2] + output_sizes[3]));
  ASSERT_NE(output_, nullptr);
  float *output[CNN_MAX_CHANNELS] = { nullptr };
  int ch_ite = 0;
  float *output_ite = output_;
  for (int output_idx = 0; output_idx < num_outputs; output_idx++) {
    for (int channel = 0; channel < output_chs[output_idx]; ++channel) {
      output[ch_ite++] = output_ite;
      output_ite += output_dims[output_idx] * output_dims[output_idx];
    }
  }
  CNN_MULTI_OUT output_struct = { num_outputs, output_chs, output_dims,
                                  output };

  RunMultiOutCNNTest(input, image_dim, image_dim, image_dim, &cnn_config,
                     &thread_data, &output_struct, expected, MSE_FLOAT_TOL);

  aom_free(output_);
}

namespace {

typedef void (*CNNConvolveNoMaxpoolPaddingValidFunc)(
    const float **input, int in_width, int in_height, int in_stride,
    const CNN_LAYER_CONFIG *layer_config, float **output, int out_stride,
    int start_idx, int cstep, int channel_step);

typedef libaom_test::FuncParam<CNNConvolveNoMaxpoolPaddingValidFunc>
    CNNConvolveTestFuncs;

class CNNConvolveTest : public ::testing::TestWithParam<CNNConvolveTestFuncs> {
 protected:
  virtual void SetUp() { params_ = GetParam(); }

  void RunCNNConvolveSetup(int run_times) {
    int in_width = 65;
    int in_height = 65;

    const CNN_CONFIG *cnn_config = &av1_intra_mode_cnn_partition_cnn_config;

    for (int layer = 0; layer < cnn_config->num_layers; ++layer) {
      int out_width = 0, out_height = 0;
      int in_size = in_width * in_height;
      // Get current layer output width and height.
      av1_find_cnn_layer_output_size(in_height, in_width,
                                     &cnn_config->layer_config[layer],
                                     &out_width, &out_height);

      int out_size = out_width * out_height;
      float *input[20], *output_ref[20], *output_mod[20];

      float *input_data =
          (float *)aom_malloc(sizeof(*input_data) * in_size *
                              cnn_config->layer_config[layer].in_channels);
      float *temp_ptr = input_data;
      ASSERT_NE(temp_ptr, nullptr);
      for (int i = 0; i < cnn_config->layer_config[layer].in_channels; ++i) {
        input[i] = temp_ptr;
        for (int j = 0; j < in_size; j++) {
          *(temp_ptr++) = ((float)rng_.Rand31() - (1 << 30)) / (1u << 31);
        }
      }

      float *out_data_ref = (float *)aom_calloc(
          sizeof(*out_data_ref),
          out_size * cnn_config->layer_config[layer].out_channels);
      ASSERT_NE(out_data_ref, nullptr);
      float *out_data_mod = (float *)aom_calloc(
          sizeof(*out_data_mod),
          out_size * cnn_config->layer_config[layer].out_channels);
      ASSERT_NE(out_data_mod, nullptr);
      float *temp_ptr1 = out_data_ref;
      float *temp_ptr2 = out_data_mod;
      for (int i = 0; i < cnn_config->layer_config[layer].out_channels; ++i) {
        output_ref[i] = temp_ptr1;
        output_mod[i] = temp_ptr2;
        temp_ptr1 += out_size;
        temp_ptr2 += out_size;
      }

      RunCNNConvolveTest(input, in_width, in_height, out_size,
                         &cnn_config->layer_config[layer], 0, 1, run_times,
                         layer, output_ref, output_mod, out_width);

      // Set current layer output width and height as next layer input width and
      // height.
      in_width = out_width;
      in_height = out_height;

      aom_free(input_data);
      aom_free(out_data_ref);
      aom_free(out_data_mod);
    }
  }

  void RunCNNConvolveTest(float **input, int in_width, int in_height,
                          int out_size, const CNN_LAYER_CONFIG *layer_config,
                          int start_idx, int step, int run_times, int layer,
                          float **output_ref, float **output_mod,
                          int out_stride) {
    const int cstep = layer_config->in_channels * layer_config->out_channels;
    const int channel_step = AOMMAX(step, 1);
    aom_usec_timer timer;
    aom_usec_timer_start(&timer);
    for (int i = 0; i < run_times; ++i) {
      params_.ref_func((const float **)input, in_width, in_height, in_width,
                       layer_config, output_ref, out_stride, start_idx, cstep,
                       channel_step);
    }
    aom_usec_timer_mark(&timer);
    const double time1 = static_cast<double>(aom_usec_timer_elapsed(&timer));

    aom_usec_timer_start(&timer);
    for (int i = 0; i < run_times; ++i) {
      params_.tst_func((const float **)input, in_width, in_height, in_width,
                       layer_config, output_mod, out_stride, start_idx, cstep,
                       channel_step);
    }
    aom_usec_timer_mark(&timer);
    const double time2 = static_cast<double>(aom_usec_timer_elapsed(&timer));

    if (run_times > 1) {
      printf("layer : %d \n", layer);
      printf("%7.2f/%7.2fns (%3.2f)\n", time1, time2, time1 / time2);
    } else {
      for (int channel = 0; channel < layer_config->out_channels; ++channel) {
        const float *buf_ref = output_ref[channel];
        const float *buf_mod = output_mod[channel];

        for (int i = 0; i < out_size; ++i) {
          if (buf_ref[i] < CNN_CONVOLVE_PIXELWISE_FLOAT_TOL) {
            ASSERT_LE(buf_ref[i], CNN_CONVOLVE_PIXELWISE_FLOAT_TOL)
                << "Reference output was near-zero, test output was not ("
                << buf_mod[i] << ")";
          } else {
            const float error = buf_ref[i] - buf_mod[i];
            const float relative_error = fabsf(error / buf_ref[i]);
            ASSERT_LE(relative_error, CNN_CONVOLVE_PIXELWISE_FLOAT_TOL)
                << " channel " << channel << " pixel " << i << ": "
                << buf_ref[i] << "/" << buf_mod[i] << std::endl;
          }
        }
      }
    }
  }

 private:
  CNNConvolveTestFuncs params_;
  libaom_test::ACMRandom rng_;
};
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(CNNConvolveTest);

TEST_P(CNNConvolveTest, CheckOutput) { RunCNNConvolveSetup(1); }

TEST_P(CNNConvolveTest, DISABLED_Speed) { RunCNNConvolveSetup(100000); }

#if HAVE_AVX2 && !CONFIG_EXCLUDE_SIMD_MISMATCH
INSTANTIATE_TEST_SUITE_P(AVX2, CNNConvolveTest,
                         ::testing::Values(CNNConvolveTestFuncs(
                             &av1_cnn_convolve_no_maxpool_padding_valid_c,
                             &av1_cnn_convolve_no_maxpool_padding_valid_avx2)));
#endif

}  // namespace