305 lines
8.6 KiB
C++
305 lines
8.6 KiB
C++
|
|
#include "gtest/gtest.h"
|
|
#include "gmock/gmock.h"
|
|
|
|
#include <iostream>
|
|
#include <bitset>
|
|
|
|
#include "Hamming.hpp"
|
|
|
|
class HammingTest : public testing::Test
|
|
{
|
|
protected:
|
|
|
|
static void print_debug(int value, int fixed, int error_count)
|
|
{
|
|
std::cout << std::bitset<10>(value) << ": ";
|
|
switch (error_count) {
|
|
case 0:
|
|
std::cout << "OK";
|
|
break;
|
|
case 1:
|
|
std::cout << "one error detected, hopefully fixed: " << std::bitset<6>(fixed);
|
|
break;
|
|
case 2:
|
|
std::cout << "irrecoverable :(";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
static void check_decode(int v, int expected_v, int expected_errors)
|
|
{
|
|
Hamming_10_6_3 hamming;
|
|
Hamming_10_6_3_TableImpl hamming_table;
|
|
|
|
int output_1;
|
|
int output_2;
|
|
int error_count_1 = hamming.decode(v, &output_1);
|
|
int error_count_2 = hamming_table.decode(v, &output_2);
|
|
|
|
//print_debug(v, output_1, error_count_1);
|
|
|
|
if (expected_errors != -1) {
|
|
EXPECT_EQ(expected_errors, error_count_1);
|
|
}
|
|
EXPECT_EQ(error_count_1, error_count_2);
|
|
|
|
if (expected_v != -1) {
|
|
EXPECT_EQ(expected_v, output_1);
|
|
}
|
|
EXPECT_EQ(output_1, output_2);
|
|
}
|
|
|
|
static void check_decode(Hamming_Inteface* hamming, char* hex, char* parity, int expected_errors, char* expected)
|
|
{
|
|
int value = Hamming_10_6_3_TableImpl::convert_hex_parity_to_int(hex, parity);
|
|
int error_count = hamming->decode(hex, parity);
|
|
int fixed = Hamming_10_6_3_TableImpl::convert_hex_to_int(hex);
|
|
|
|
//print_debug(value, fixed, error_count);
|
|
|
|
EXPECT_EQ(expected_errors, error_count);
|
|
for (unsigned int i=0; i<6; i++) {
|
|
EXPECT_EQ(expected[i], hex[i]);
|
|
}
|
|
}
|
|
|
|
static void check_encode(Hamming_Inteface* hamming, int input)
|
|
{
|
|
int parity = hamming->encode(input);
|
|
|
|
// Check it
|
|
EXPECT_LT(parity, 16);
|
|
int v = (input << 4) | parity;
|
|
int output;
|
|
int error_count = hamming->decode(v, &output);
|
|
EXPECT_EQ(error_count, 0);
|
|
EXPECT_EQ(output, input);
|
|
}
|
|
|
|
static void check_encode(Hamming_Inteface* hamming, char* hex)
|
|
{
|
|
char parity[4];
|
|
hamming->encode(hex, parity);
|
|
|
|
// Check it
|
|
int error_count = hamming->decode(hex, parity);
|
|
EXPECT_EQ(error_count, 0);
|
|
}
|
|
};
|
|
|
|
TEST_F(HammingTest, Test1)
|
|
{
|
|
// OK
|
|
std::bitset<10> value(std::string("1010100110"));
|
|
std::bitset< 6> expected(std::string("101010"));
|
|
check_decode((int)value.to_ulong(), (int)expected.to_ulong(), 0);
|
|
}
|
|
|
|
TEST_F(HammingTest, Test2)
|
|
{
|
|
// Error on parity bit 0 (9 is the left-most and 0 is the right-most)
|
|
std::bitset<10> value(std::string("1010100111"));
|
|
std::bitset< 6> expected(std::string("101010"));
|
|
check_decode((int)value.to_ulong(), (int)expected.to_ulong(), 1);
|
|
}
|
|
|
|
TEST_F(HammingTest, Test3)
|
|
{
|
|
// Error on parity bit 1 (9 is the left-most and 0 is the right-most)
|
|
std::bitset<10> value(std::string("1010100100"));
|
|
std::bitset< 6> expected(std::string("101010"));
|
|
check_decode((int)value.to_ulong(), (int)expected.to_ulong(), 1);
|
|
}
|
|
|
|
TEST_F(HammingTest, Test4)
|
|
{
|
|
// Error on parity bit 2 (9 is the left-most and 0 is the right-most)
|
|
std::bitset<10> value(std::string("1010100010"));
|
|
std::bitset< 6> expected(std::string("101010"));
|
|
check_decode((int)value.to_ulong(), (int)expected.to_ulong(), 1);
|
|
}
|
|
|
|
TEST_F(HammingTest, Test5)
|
|
{
|
|
// Error on parity bit 3 (9 is the left-most and 0 is the right-most)
|
|
std::bitset<10> value(std::string("1010101110"));
|
|
std::bitset< 6> expected(std::string("101010"));
|
|
check_decode((int)value.to_ulong(), (int)expected.to_ulong(), 1);
|
|
}
|
|
|
|
TEST_F(HammingTest, Test6)
|
|
{
|
|
// Error on bit 4 (9 is the left-most and 0 is the right-most)
|
|
std::bitset<10> value(std::string("1010110110"));
|
|
std::bitset< 6> expected(std::string("101010"));
|
|
check_decode((int)value.to_ulong(), (int)expected.to_ulong(), 1);
|
|
}
|
|
|
|
TEST_F(HammingTest, Test7)
|
|
{
|
|
// Error on bit 5 (9 is the left-most and 0 is the right-most)
|
|
std::bitset<10> value(std::string("1010000110"));
|
|
std::bitset< 6> expected(std::string("101010"));
|
|
check_decode((int)value.to_ulong(), (int)expected.to_ulong(), 1);
|
|
}
|
|
|
|
TEST_F(HammingTest, Test8)
|
|
{
|
|
// Error on bit 6 (9 is the left-most and 0 is the right-most)
|
|
std::bitset<10> value(std::string("1011100110"));
|
|
std::bitset< 6> expected(std::string("101010"));
|
|
check_decode((int)value.to_ulong(), (int)expected.to_ulong(), 1);
|
|
}
|
|
|
|
TEST_F(HammingTest, Test9)
|
|
{
|
|
// Error on bit 7 (9 is the left-most and 0 is the right-most)
|
|
std::bitset<10> value(std::string("1000100110"));
|
|
std::bitset< 6> expected(std::string("101010"));
|
|
check_decode((int)value.to_ulong(), (int)expected.to_ulong(), 1);
|
|
}
|
|
|
|
TEST_F(HammingTest, Test10)
|
|
{
|
|
// Error on bit 8 (9 is the left-most and 0 is the right-most)
|
|
std::bitset<10> value(std::string("1110100110"));
|
|
std::bitset< 6> expected(std::string("101010"));
|
|
check_decode((int)value.to_ulong(), (int)expected.to_ulong(), 1);
|
|
}
|
|
|
|
TEST_F(HammingTest, Test11)
|
|
{
|
|
// Error on bit 9 (9 is the left-most and 0 is the right-most)
|
|
std::bitset<10> value(std::string("0010100110"));
|
|
std::bitset< 6> expected(std::string("101010"));
|
|
check_decode((int)value.to_ulong(), (int)expected.to_ulong(), 1);
|
|
}
|
|
|
|
TEST_F(HammingTest, Test12)
|
|
{
|
|
// Two errors
|
|
std::bitset<10> value(std::string("0010100111"));
|
|
std::bitset< 6> expected(std::string("001010"));
|
|
check_decode((int)value.to_ulong(), (int)expected.to_ulong(), 2);
|
|
}
|
|
|
|
TEST_F(HammingTest, Test13)
|
|
{
|
|
// Two errors, in this case they go undetected, thinks it's a parity error
|
|
std::bitset<10> value(std::string("1011000110"));
|
|
std::bitset< 6> expected(std::string("101100"));
|
|
check_decode((int)value.to_ulong(), (int)expected.to_ulong(), 1);
|
|
}
|
|
|
|
TEST_F(HammingTest, Test14)
|
|
{
|
|
// OK
|
|
std::bitset<10> value(std::string("0001000111"));
|
|
std::bitset< 6> expected(std::string("000100"));
|
|
check_decode((int)value.to_ulong(), (int)expected.to_ulong(), 0);
|
|
}
|
|
|
|
TEST_F(HammingTest, TestEveryValue)
|
|
{
|
|
// Test every posible value
|
|
for (int v=0; v<1023; v++) {
|
|
check_decode(v, -1, -1);
|
|
}
|
|
}
|
|
|
|
TEST_F(HammingTest, Test_hex_parity_interface_no_errors)
|
|
{
|
|
char hex [6] = {1,1,1,0,1,0};
|
|
char fixed [6] = {1,1,1,0,1,0};
|
|
char parity[4] = {1,0,1,1};
|
|
|
|
Hamming_10_6_3 hamming;
|
|
check_decode(&hamming, hex, parity, 0, fixed);
|
|
|
|
Hamming_10_6_3_TableImpl hamming_table;
|
|
check_decode(&hamming_table, hex, parity, 0, fixed);
|
|
}
|
|
|
|
TEST_F(HammingTest, Test_hex_parity_interface_one_error_1)
|
|
{
|
|
char hex_1 [6] = {1,1,1,1,1,0};
|
|
char hex_2 [6] = {1,1,1,1,1,0};
|
|
char fixed [6] = {1,1,1,0,1,0};
|
|
char parity[4] = {1,0,1,1};
|
|
|
|
Hamming_10_6_3 hamming;
|
|
check_decode(&hamming, hex_1, parity, 1, fixed);
|
|
// hex is modified in place
|
|
|
|
Hamming_10_6_3_TableImpl hamming_table;
|
|
check_decode(&hamming_table, hex_2, parity, 1, fixed);
|
|
// hex is modified in place
|
|
}
|
|
|
|
TEST_F(HammingTest, Test_hex_parity_interface_one_error_2)
|
|
{
|
|
char hex_1 [6] = {1,1,1,1,1,0};
|
|
char hex_2 [6] = {1,1,1,1,1,0};
|
|
char fixed [6] = {1,1,1,1,1,1};
|
|
char parity[4] = {0,0,0,0};
|
|
|
|
Hamming_10_6_3 hamming;
|
|
check_decode(&hamming, hex_1, parity, 1, fixed);
|
|
// hex is modified in place
|
|
|
|
Hamming_10_6_3_TableImpl hamming_table;
|
|
check_decode(&hamming_table, hex_2, parity, 1, fixed);
|
|
// hex is modified in place
|
|
}
|
|
|
|
TEST_F(HammingTest, Test_hex_parity_interface_one_error_3)
|
|
{
|
|
char hex_1 [6] = {1,0,0,0,0,0};
|
|
char hex_2 [6] = {1,0,0,0,0,0};
|
|
char fixed [6] = {0,0,0,0,0,0};
|
|
char parity[4] = {0,0,0,0};
|
|
|
|
Hamming_10_6_3 hamming;
|
|
check_decode(&hamming, hex_1, parity, 1, fixed);
|
|
// hex is modified in place
|
|
|
|
Hamming_10_6_3_TableImpl hamming_table;
|
|
check_decode(&hamming_table, hex_2, parity, 1, fixed);
|
|
// hex is modified in place
|
|
}
|
|
|
|
TEST_F(HammingTest, Test_encoding_1)
|
|
{
|
|
Hamming_10_6_3 hamming;
|
|
Hamming_10_6_3_TableImpl hamming_table;
|
|
|
|
for (int i=0; i<64; i++) {
|
|
check_encode(&hamming, i);
|
|
check_encode(&hamming_table, i);
|
|
}
|
|
}
|
|
|
|
TEST_F(HammingTest, Test_encoding_char)
|
|
{
|
|
Hamming_10_6_3 hamming;
|
|
Hamming_10_6_3_TableImpl hamming_table;
|
|
|
|
char hex[6];
|
|
|
|
for (int i=0; i<64; i++) {
|
|
|
|
// Convert i to char array
|
|
int input = i;
|
|
for (int j=5; j>=0; j--) {
|
|
hex[j] = input & 1;
|
|
input >>= 1;
|
|
}
|
|
check_encode(&hamming, hex);
|
|
check_encode(&hamming_table, hex);
|
|
}
|
|
}
|