price_speedometer/circular_buffer_test.mq5

#include "circular_buffer.mqh"

void OnStart() {
  test_empty_buffer_size();
  test_non_empty_buffer_size();
  test_empty_buffer_incorrect_position_offset();
  test_empty_buffer_current_position_offset();
  test_empty_buffer_previous_position_offset();
  test_non_empty_buffer_current_position_offset();
  test_non_empty_buffer_previous_position_offset();
  test_non_empty_buffer_a_few_position_offsets();
  test_non_empty_buffer_a_few_position_offsets_a_lot_of_values();
  test_copy_constructor();
  test_copy_assignment();
  Print("All tests passed.");
  return;
}

void test_empty_buffer_size() {
  const int capacity = 65536;
  const Circular_buffer<int> circular_buffer(capacity);
  const int input_value = 0;
  const int output_value = circular_buffer.get_size();
  if (output_value != input_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
}

void test_non_empty_buffer_size() {
  const int capacity = 65536;
  Circular_buffer<int> circular_buffer(capacity);
  const int input_value = 3;
  circular_buffer.write(input_value);
  circular_buffer.write(input_value);
  circular_buffer.write(input_value);
  const int output_value = circular_buffer.get_size();
  if (output_value != input_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
}

void test_empty_buffer_incorrect_position_offset() {
  const int capacity = 65536;
  const Circular_buffer<int> circular_buffer(capacity);
  const int input_value = 1;
  const int position_offset = -1;
  int output_value = 1;
  const bool return_value = circular_buffer.read(position_offset, output_value);
  if (output_value != input_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (return_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_empty_buffer_current_position_offset() {
  const int capacity = 65536;
  const Circular_buffer<int> circular_buffer(capacity);
  const int input_value = 1;
  const int position_offset = 0;
  int output_value = 1;
  const bool return_value = circular_buffer.read(position_offset, output_value);
  if (output_value != input_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (return_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_empty_buffer_previous_position_offset() {
  const int capacity = 65536;
  const Circular_buffer<int> circular_buffer(capacity);
  const int input_value = 1;
  const int position_offset = 1;
  int output_value = 1;
  const bool return_value = circular_buffer.read(position_offset, output_value);
  if (output_value != input_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (return_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_non_empty_buffer_current_position_offset() {
  const int capacity = 65536;
  Circular_buffer<int> circular_buffer(capacity);
  const int input_value = 1;
  circular_buffer.write(input_value);
  const int position_offset = 0;
  int output_value = 0;
  const bool return_value = circular_buffer.read(position_offset, output_value);
  if (output_value != input_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (!return_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_non_empty_buffer_previous_position_offset() {
  const int capacity = 65536;
  Circular_buffer<int> circular_buffer(capacity);
  const int input_value = 1;
  circular_buffer.write(input_value);
  const int position_offset = 1;
  int output_value = 1;
  const bool return_value = circular_buffer.read(position_offset, output_value);
  if (output_value != input_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (return_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_non_empty_buffer_a_few_position_offsets() {
  const int capacity = 65536;
  Circular_buffer<int> circular_buffer(capacity);
  const int input_value_1 = 1;
  circular_buffer.write(input_value_1);
  const int input_value_2 = 2;
  circular_buffer.write(input_value_2);
  const int input_value_3 = 3;
  circular_buffer.write(input_value_3);
  int position_offset = 0;
  int output_value = 0;
  bool return_value = circular_buffer.read(position_offset, output_value);
  if (output_value != input_value_3) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (!return_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  position_offset = 1;
  output_value = 0;
  return_value = circular_buffer.read(position_offset, output_value);
  if (output_value != input_value_2) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (!return_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  position_offset = 2;
  output_value = 0;
  return_value = circular_buffer.read(position_offset, output_value);
  if (output_value != input_value_1) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (!return_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_non_empty_buffer_a_few_position_offsets_a_lot_of_values() {
  const int capacity = 65536;
  Circular_buffer<int> circular_buffer(capacity);
  for (int input_value = 0; input_value < 65540; ++input_value) {
    circular_buffer.write(input_value);
  }
  int input_value = 65539;
  int position_offset = 0;
  int output_value = 0;
  bool return_value = circular_buffer.read(position_offset, output_value);
  if (output_value != input_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (!return_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  input_value = 65536;
  position_offset = 3;
  output_value = 0;
  return_value = circular_buffer.read(position_offset, output_value);
  if (output_value != input_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (!return_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  input_value = 65533;
  position_offset = 6;
  output_value = 0;
  return_value = circular_buffer.read(position_offset, output_value);
  if (output_value != input_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (!return_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_copy_constructor() {
  const int capacity = 65536;
  Circular_buffer<int> circular_buffer_1(capacity);
  const int input_value = 1;
  circular_buffer_1.write(input_value);
  const Circular_buffer<int> circular_buffer_2(circular_buffer_1);
  const int position_offset = 0;
  int output_value = 0;
  const bool return_value =
      circular_buffer_2.read(position_offset, output_value);
  if (output_value != input_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (!return_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_copy_assignment() {
  const int capacity = 65536;
  Circular_buffer<int> circular_buffer_1(capacity);
  const int input_value = 1;
  circular_buffer_1.write(input_value);
  const Circular_buffer<int> circular_buffer_2 = circular_buffer_1;
  const int position_offset = 0;
  int output_value = 0;
  const bool return_value =
      circular_buffer_2.read(position_offset, output_value);
  if (output_value != input_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (!return_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}