mpd/test/test_byte_reverse.cxx
Michael Cree 72637d00e8 Bug#822848: mpd FTBFS on Alpha; misaligned arrays in the test suite
Source: mpd
Version: 0.19.14-2
Severity: important
Justification: fails to build form source (but built in the past)
Tags: patch
User: debian-alpha@lists.debian.org
Usertags: alpha

mpd FTBFS on Alpha with a failure in the test suite [1]:

FAIL: test/test_byte_reverse
============================

.F...

!!!FAILURES!!!
Test Results:
Run:  4   Failures: 1   Errors: 0

1) test: ByteReverseTest::TestByteReverse2 (F) line: 58 test/test_byte_reverse.cxx
assertion failed
- Expression: strcmp(result, (const char *)dest) == 0

This occurs because the test suite (in test/test_byte_reversal.cxx)
allocates static char arrays and passes the char arrays to functions
whose respective arguments were declared to be uint16_t *, etc., in
the main code.

This is in the realm of undefined behaviour on architectures with
strict memory alignment requirements.  Although the test only fails
on Alpha (because Alpha has a particular CPU load instruction that
gcc likes to use to add bugs ..., ahem,  optimise the code on the
assumption of alignment) it is potentially a latent bug for other
architectures with strict alignment requirements.

Since the code is compiled with the c++11 standard I attach a patch
that modifies the test suite to align the non-compliant strings with
the alignas() attribute.  The test suite now passes on Alpha with
that patch.

Cheers
Michael

[1] https://buildd.debian.org/status/fetch.php?pkg=mpd&arch=alpha&ver=0.19.14-2&stamp=1461542099
2016-04-28 13:29:41 +02:00

105 lines
3.1 KiB
C++

/*
* Copyright (C) 2003-2014 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "util/ByteReverse.hxx"
#include "util/Macros.hxx"
#include "Compiler.h"
#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/ui/text/TestRunner.h>
#include <string.h>
#include <stdlib.h>
class ByteReverseTest : public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE(ByteReverseTest);
CPPUNIT_TEST(TestByteReverse2);
CPPUNIT_TEST(TestByteReverse3);
CPPUNIT_TEST(TestByteReverse4);
CPPUNIT_TEST(TestByteReverse5);
CPPUNIT_TEST_SUITE_END();
public:
void TestByteReverse2();
void TestByteReverse3();
void TestByteReverse4();
void TestByteReverse5();
};
CPPUNIT_TEST_SUITE_REGISTRATION(ByteReverseTest);
void
ByteReverseTest::TestByteReverse2()
{
static const char src[] alignas(uint16_t) = "123456";
static const char result[] = "214365";
static uint8_t dest[ARRAY_SIZE(src)] alignas(uint16_t);
reverse_bytes(dest, (const uint8_t *)src,
(const uint8_t *)(src + ARRAY_SIZE(src) - 1), 2);
CPPUNIT_ASSERT(strcmp(result, (const char *)dest) == 0);
}
void
ByteReverseTest::TestByteReverse3()
{
static const char src[] = "123456";
static const char result[] = "321654";
static uint8_t dest[ARRAY_SIZE(src)];
reverse_bytes(dest, (const uint8_t *)src,
(const uint8_t *)(src + ARRAY_SIZE(src) - 1), 3);
CPPUNIT_ASSERT(strcmp(result, (const char *)dest) == 0);
}
void
ByteReverseTest::TestByteReverse4()
{
static const char src[] alignas(uint32_t) = "12345678";
static const char result[] = "43218765";
static uint8_t dest[ARRAY_SIZE(src)] alignas(uint32_t);
reverse_bytes(dest, (const uint8_t *)src,
(const uint8_t *)(src + ARRAY_SIZE(src) - 1), 4);
CPPUNIT_ASSERT(strcmp(result, (const char *)dest) == 0);
}
void
ByteReverseTest::TestByteReverse5()
{
static const char src[] = "1234567890";
static const char result[] = "5432109876";
static uint8_t dest[ARRAY_SIZE(src)];
reverse_bytes(dest, (const uint8_t *)src,
(const uint8_t *)(src + ARRAY_SIZE(src) - 1), 5);
CPPUNIT_ASSERT(strcmp(result, (const char *)dest) == 0);
}
int
main(gcc_unused int argc, gcc_unused char **argv)
{
CppUnit::TextUi::TestRunner runner;
auto &registry = CppUnit::TestFactoryRegistry::getRegistry();
runner.addTest(registry.makeTest());
return runner.run() ? EXIT_SUCCESS : EXIT_FAILURE;
}