code. compile. run. debug. share.
#include <iostream>
#include <vector>
#include "counter.h"
#include "tests.h"
void Initialize(std::vector<Counter> *counters, const int number,
const int init_value)
{
for (auto i = 0; i < number; i++) {
counters->emplace_back(init_value);
}
}
void Show(const std::vector<Counter> &counters, const char *message)
{
std::cout << "\n" << message << ":\n";
for (const auto &counter : counters) {
std::cout << counter.GetValue() << "\n";
}
}
void Count(std::vector<Counter> *counters, const int step)
{
for (auto &counter : *counters) {
counter.Count(step);
}
}
void PlayWithCounters()
{
std::vector<Counter> counters_1;
std::vector<Counter> counters_2;
Initialize(&counters_1, 5, 0);
Initialize(&counters_2, 3, 10);
Show(counters_1, "Vector 1");
Show(counters_2, "Vector 2");
for (auto i = 0; i < 3; i++) {
Count(&counters_1, 1);
Count(&counters_2, -1);
}
Show(counters_1, "Vector 1");
Show(counters_2, "Vector 2");
}
int main()
{
PlayWithCounters();
std::cout << "\n------------------------------------\n\n";
RunTests();
return 0;
}
#ifndef COUNTER_H_
#define COUNTER_H_
class Counter {
private:
int value_;
public:
explicit Counter(int value = 0);
void SetValue(int value);
int GetValue() const;
void Count(int step);
bool operator<(const Counter& counter) const;
bool operator==(const Counter& counter) const;
};
#endif // COUNTER_H_
#include "counter.h"
Counter::Counter(const int value) : value_(value) {}
void Counter::SetValue(const int value) { value_ = value; }
int Counter::GetValue() const { return value_; }
void Counter::Count(const int step) { value_ += step; }
bool Counter::operator<(const Counter& counter) const
{
return value_ < counter.value_;
}
bool Counter::operator==(const Counter& counter) const
{
return value_ == counter.value_;
}
#ifndef TESTS_H_
#define TESTS_H_
void RunTests();
#endif // TESTS_H_
#include "tests.h"
#include "test_functions.h"
#include "counter.h"
void CountHelper(Counter* counter, const int loops, const int step)
{
for (auto i = 0; i < loops; i++) {
counter->Count(step);
}
}
TEST(TestCounterInit1)
{
const auto expected = 0;
Counter counter;
ASSERT(counter.GetValue() == expected, "Counter initialization failed");
}
TEST(TestCounterInit2)
{
const auto expected = 42;
Counter counter(expected);
ASSERT(counter.GetValue() == expected, "Counter initialization failed");
}
TEST(TestCounterInit3)
{
const auto expected = 42;
const auto step = 1;
const Counter counter_base(expected);
ASSERT_INT(counter_base.GetValue(), expected);
auto counter(counter_base);
ASSERT(counter.GetValue() == expected, "Counter initialization failed");
counter.Count(step);
ASSERT(counter.GetValue() == expected + step,
"Counter initialization failed");
}
TEST(TestCounterCount1)
{
const auto expected = 4;
const auto step = 1;
Counter counter;
CountHelper(&counter, expected, step);
ASSERT_INT(counter.GetValue(), expected);
}
TEST(TestCounterCount2)
{
const auto init_value = 10;
const auto expected = 4;
const auto step = -1;
Counter counter(init_value);
CountHelper(&counter, init_value - expected, step);
ASSERT_INT(counter.GetValue(), expected);
}
TEST(TestCounterSetValue)
{
const auto expected = 4;
Counter counter;
counter.SetValue(expected);
ASSERT_INT(counter.GetValue(), expected);
}
TEST(TestCounterCopy)
{
const auto init_value = 10;
const auto expected = 42;
const Counter counter_base(expected);
Counter counter(init_value);
ASSERT_INT(counter.GetValue(), init_value);
counter = counter_base;
ASSERT(counter.GetValue() == expected, "Counter copy failed");
}
TEST(TestCounterCompare1)
{
const Counter counter_left(2);
const Counter counter_right(5);
ASSERT(counter_left < counter_right, "Counter comparison failed");
}
TEST(TestCounterCompare2)
{
const Counter counter_left(5);
const Counter counter_right(5);
ASSERT(!(counter_left < counter_right), "Counter comparison failed");
}
TEST(TestCounterCompare3)
{
const Counter counter_left(23);
const Counter counter_right(5);
ASSERT(!(counter_left < counter_right), "Counter comparison failed");
}
TEST(TestCounterCompare4)
{
const Counter counter_left(2);
const Counter counter_right(5);
ASSERT(!(counter_left == counter_right), "Counter comparison failed");
}
TEST(TestCounterCompare5)
{
const Counter counter_left(5);
const Counter counter_right(5);
ASSERT(counter_left == counter_right, "Counter comparison failed");
}
TEST(TestCounterCompare6)
{
const Counter counter_left(23);
const Counter counter_right(5);
ASSERT(!(counter_left == counter_right), "Counter comparison failed");
}
TEST_SUITE(TestCounter)
{
RUN_TEST(TestCounterInit1);
RUN_TEST(TestCounterInit2);
RUN_TEST(TestCounterInit3);
RUN_TEST(TestCounterCount1);
RUN_TEST(TestCounterCount2);
RUN_TEST(TestCounterSetValue);
RUN_TEST(TestCounterCopy);
RUN_TEST(TestCounterCompare1);
RUN_TEST(TestCounterCompare2);
RUN_TEST(TestCounterCompare3);
RUN_TEST(TestCounterCompare4);
RUN_TEST(TestCounterCompare5);
RUN_TEST(TestCounterCompare6);
}
void RunTests() { RUN_TEST_SUITE(TestCounter); }
// Copyright 2018 MicroConsult GmbH
#ifndef TEST_FUNCTIONS_H_
#define TEST_FUNCTIONS_H_
#include <stdio.h>
static const int test_message_buffer_size = 1024;
static char test_message_buffer[test_message_buffer_size];
#define TEST(fx) static void fx(const char** message)
#define TEST_SUITE(fx) void fx(int* tests_total, int* tests_successful)
#define RUN_TEST(test) \
do { \
const char* message = nullptr; \
++*tests_total; \
test(&message); \
if (message) { \
printf("--- ERROR (%s): %s \n", #test, message); \
} \
else { \
++*tests_successful; \
printf("+++ passed: %s\n", #test); \
} \
} while (0)
#define RUN_TEST_SUITE(test_suite) \
do { \
int tests_total = 0; \
int tests_successful = 0; \
test_suite(&tests_total, &tests_successful); \
printf("-----------------------------------------------\n"); \
if (tests_successful == tests_total) { \
printf("+ Test Suite '%s': all %d tests passed\n\n", #test_suite, \
tests_total); \
} \
else { \
printf("- Test Suite '%s': %d of %d tests passed\n\n", #test_suite, \
tests_successful, tests_total); \
} \
} while (false)
#define ASSERT(test, error_message) \
do { \
if (test) { \
*message = nullptr; \
} \
else { \
snprintf(test_message_buffer, test_message_buffer_size - 1, \
error_message); \
*message = test_message_buffer; \
return; \
} \
} while (false)
#define ASSERT_INT(value, expected) \
do { \
if (value == expected) { \
*message = nullptr; \
} \
else { \
snprintf(test_message_buffer, test_message_buffer_size - 1, \
"Wrong value - expected: %d, current value: %d", expected, \
value); \
*message = test_message_buffer; \
return; \
} \
} while (false)
#endif // TEST_FUNCTIONS_H_
Compiling Program...
Standard Input:
Interactive Console
Text
Program is not being debugged. Click "Debug" button to start program in debug mode.
| # | Function | File:Line |
|---|
| Variable | Value |
|---|
| Register | Value |
|---|
| Expression | Value |
|---|
| # | Description |
|---|