crewID/libfreefare
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add regression test suite.

Browse source
This commit is contained in:
Romain Tartiere 2009-12-19 02:06:21 +00:00
parent 1f40cc97c7
commit b97012ac05
12 changed files with 1952 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

46
test/Makefile Normal file
View file

@ -0,0 +1,46 @@
LMF_SRCDIR= ${.CURDIR}/..
.PATH: ${LMF_SRCDIR}
#LMF_SRCS!= ${MAKE} -f ${LMF_SRCDIR}/Makefile -V SRCS
LMF_SRCS= ../mifare_classic.c
TESTS= test_read_sector_0.c \
test_authenticate.c \
test_value_block.c \
test_access_bits.c \
test_format.c
SRCS= ${LMF_SRCS} \
${TESTS} \
main.c \
mifare_classic_test.c
# list.h must be up-to-date before building main.o
main.o: list.h
NO_MAN=
PROG= libfreefare_test
INTERNALPROG= yes
LDADD+= -lnfc
CFLAGS+= -std=c99
CFLAGS+= -ggdb
CFLAGS+= -Wall -pedantic
CFLAGS+= -I${LMF_SRCDIR} -I.
.PHONY: check test
check test: libfreefare_test
./libfreefare_test
# list.h is just a list of all tests, as indicated by DEFINE_TEST macro lines
list.h: ${TESTS} Makefile
(cd ${.CURDIR}; cat test_*.c) | grep DEFINE_TEST > list.h
CLEANFILES+= list.h
cleantest:
-chmod -R +w /tmp/${PROG}.*
-rm -rf /tmp/${PROG}.*
.include <bsd.prog.mk>

1235
test/main.c Normal file
View file

File diff suppressed because it is too large Load diff

67
test/mifare_classic_test.c Normal file
View file

@ -0,0 +1,67 @@
#include "test.h"
static nfc_device_t *device;
static MifareClassicTag *tags;
int
mifare_classic_test_setup (MifareClassicTag *tag)
{
int res = 0;
device = nfc_connect (NULL);
if (!device)
res = -1;
if (0 == res) {
tags = mifare_classic_get_tags (device);
if (!tags || !(tags[0])) {
nfc_disconnect (device);
res = -2;
}
}
if (0 == res) {
*tag = tags[0];
res = mifare_classic_connect (*tag);
if (res != 0) {
mifare_classic_disconnect (*tag);
nfc_disconnect (device);
res = -3;
}
}
return res;
}
int
mifare_classic_test_teardown (MifareClassicTag tag)
{
int res;
res = mifare_classic_disconnect (tag);
if (0 == res) {
mifare_classic_free_tags (tags);
nfc_disconnect (device);
}
return res;
}
int
read_data_block (char *filename, MifareClassicBlock *block)
{
FILE *f = fopen (filename, "r");
if (f == NULL)
return -1;
char buffer[17];
fgets(buffer, 17, f);
memcpy (block, buffer, 16);
fclose (f);
return 0;
}

4
test/null_value_block.uu Normal file
View file

@ -0,0 +1,4 @@
begin 644 null_value_block
0`````/____\``````/\`_P``
`
end

4
test/sample_value_block.uu Normal file
View file

@ -0,0 +1,4 @@
begin 644 sample_value_block
0Z`,``!?\___H`P```/\`_P``
`
end

211
test/test.h Normal file
View file

@ -0,0 +1,211 @@
/*
* Copyright (c) 2003-2006 Tim Kientzle
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD$
*/
/* Every test program should #include "test.h" as the first thing. */
/*
* The goal of this file (and the matching test.c) is to
* simplify the very repetitive test-*.c test programs.
*/
#if 0
#if defined(HAVE_CONFIG_H)
/* Most POSIX platforms use the 'configure' script to build config.h */
#include "config.h"
#elif defined(__FreeBSD__)
/* Building as part of FreeBSD system requires a pre-built config.h. */
#include "config_freebsd.h"
#elif defined(_WIN32) && !defined(__CYGWIN__)
/* Win32 can't run the 'configure' script. */
#include "config_windows.h"
#else
/* Warn if the library hasn't been (automatically or manually) configured. */
#error Oops: No config.h and no pre-built configuration in test.h.
#endif
#endif
#if !defined(_WIN32) || defined(__CYGWIN__)
#include <dirent.h>
#else
#include <direct.h>
#endif
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#if !defined(_WIN32) || defined(__CYGWIN__)
#include <unistd.h>
#endif
#include <wchar.h>
#ifdef USE_DMALLOC
#include <dmalloc.h>
#endif
/* No non-FreeBSD platform will have __FBSDID, so just define it here. */
#ifdef __FreeBSD__
#include <sys/cdefs.h> /* For __FBSDID */
#else
/* Some non-FreeBSD platforms such as newlib-derived ones like
* cygwin, have __FBSDID, so this definition must be guarded.
*/
#ifndef __FBSDID
#define __FBSDID(a) /* null */
#endif
#endif
#if defined(_WIN32) && !defined(__CYGWIN__)
#define snprintf sprintf_s
#define LOCALE_DE "deu"
#else
#define LOCALE_DE "de_DE.UTF-8"
#endif
#ifndef O_BINARY
#define O_BINARY 0
#endif
/*
* Redefine DEFINE_TEST for use in defining the test functions.
*/
#undef DEFINE_TEST
#define DEFINE_TEST(name) void name(void); void name(void)
/* An implementation of the standard assert() macro */
#define assert(e) test_assert(__FILE__, __LINE__, (e), #e, NULL)
/* Assert two integers are the same. Reports value of each one if not. */
#define assertEqualInt(v1,v2) \
if (!(test_assert_equal_int(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL))) break; do {} while (0)
/* Assert two strings are the same. Reports value of each one if not. */
#define assertEqualString(v1,v2) \
if (!(test_assert_equal_string(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL))) break; do {} while (0)
/* As above, but v1 and v2 are wchar_t * */
#define assertEqualWString(v1,v2) \
if (!(test_assert_equal_wstring(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL))) break; do {} while (0)
/* As above, but raw blocks of bytes. */
#define assertEqualMem(v1, v2, l) \
if (!(test_assert_equal_mem(__FILE__, __LINE__, (v1), #v1, (v2), #v2, (l), #l, NULL))) break; do {} while (0)
/* Assert two files are the same; allow printf-style expansion of second name.
* See below for comments about variable arguments here...
*/
#define assertEqualFile \
test_setup(__FILE__, __LINE__);test_assert_equal_file
/* Assert that a file is empty; supports printf-style arguments. */
#define assertEmptyFile \
test_setup(__FILE__, __LINE__);test_assert_empty_file
/* Assert that a file exists; supports printf-style arguments. */
#define assertFileExists \
test_setup(__FILE__, __LINE__);test_assert_file_exists
/* Assert that a file exists; supports printf-style arguments. */
#define assertFileNotExists \
test_setup(__FILE__, __LINE__);test_assert_file_not_exists
/* Assert that file contents match a string; supports printf-style arguments. */
#define assertFileContents \
test_setup(__FILE__, __LINE__);test_assert_file_contents
/*
* This would be simple with C99 variadic macros, but I don't want to
* require that. Instead, I insert a function call before each
* skipping() call to pass the file and line information down. Crude,
* but effective.
*/
#define skipping \
test_setup(__FILE__, __LINE__);test_skipping
/* Function declarations. These are defined in test_utility.c. */
void failure(const char *fmt, ...);
void test_setup(const char *, int);
void test_skipping(const char *fmt, ...);
int test_assert(const char *, int, int, const char *, void *);
int test_assert_empty_file(const char *, ...);
int test_assert_equal_file(const char *, const char *, ...);
int test_assert_equal_int(const char *, int, int, const char *, int, const char *, void *);
int test_assert_equal_string(const char *, int, const char *v1, const char *, const char *v2, const char *, void *);
int test_assert_equal_wstring(const char *, int, const wchar_t *v1, const char *, const wchar_t *v2, const char *, void *);
int test_assert_equal_mem(const char *, int, const void *, const char *, const void *, const char *, size_t, const char *, void *);
int test_assert_file_contents(const void *, int, const char *, ...);
int test_assert_file_exists(const char *, ...);
int test_assert_file_not_exists(const char *, ...);
/* Like sprintf, then system() */
int systemf(const char * fmt, ...);
/* Suck file into string allocated via malloc(). Call free() when done. */
/* Supports printf-style args: slurpfile(NULL, "%s/myfile", refdir); */
char *slurpfile(size_t *, const char *fmt, ...);
/* Extracts named reference file to the current directory. */
void extract_reference_file(const char *);
/* Get external gzip program name */
const char *external_gzip_program(int un);
#if 0
/*
* Special interfaces for libarchive test harness.
*/
#include "archive.h"
#include "archive_entry.h"
/* Special customized read-from-memory interface. */
int read_open_memory(struct archive *, void *, size_t, size_t);
/* "2" version exercises a slightly different set of libarchive APIs. */
int read_open_memory2(struct archive *, void *, size_t, size_t);
/*
* ARCHIVE_VERSION_STAMP first appeared in 1.9 and libarchive 2.2.4.
* We can approximate it for earlier versions, though.
* This is used to disable tests of features not present in the current
* version.
*/
#ifndef ARCHIVE_VERSION_STAMP
#define ARCHIVE_VERSION_STAMP \
(ARCHIVE_API_VERSION * 1000000 + ARCHIVE_API_FEATURE * 1000)
/* Versions of above that accept an archive argument for additional info. */
#define assertA(e) test_assert(__FILE__, __LINE__, (e), #e, (a))
#define assertEqualIntA(a,v1,v2) \
test_assert_equal_int(__FILE__, __LINE__, (v1), #v1, (v2), #v2, (a))
#define assertEqualStringA(a,v1,v2) \
test_assert_equal_string(__FILE__, __LINE__, (v1), #v1, (v2), #v2, (a))
#endif
#endif
/*
* Special interfaces for libfreefare test harness.
*/
#include <nfc/nfc.h>
#include <mifare_classic.h>
int mifare_classic_test_setup (MifareClassicTag *tag);
int mifare_classic_test_teardown (MifareClassicTag tag);
int read_data_block (char *filename, MifareClassicBlock *block);

80
test/test_access_bits.c Normal file
View file

@ -0,0 +1,80 @@
#include "test.h"
DEFINE_TEST(access_bit_read_data_block)
{
int res;
MifareClassicTag tag;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicKey k = { 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7 };
res = mifare_classic_authenticate (tag, 0x04, k, MFC_KEY_A);
assertEqualInt (res, 0);
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_R, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_R, MFC_KEY_B) );
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_W, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_W, MFC_KEY_B) );
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_D, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_D, MFC_KEY_B) );
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_I, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_I, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_KEYA, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_KEYA, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_KEYA, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_KEYA, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_ACCESS_BITS, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_ACCESS_BITS, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_ACCESS_BITS, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_ACCESS_BITS, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_KEYB, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_KEYB, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_KEYB, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_KEYB, MFC_KEY_B) );
} while (0);
mifare_classic_test_teardown (tag);
}
DEFINE_TEST(access_bit_read_trailer_block)
{
int res;
MifareClassicTag tag;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicKey k = { 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7 };
res = mifare_classic_authenticate (tag, 0x07, k, MFC_KEY_A);
assertEqualInt (res, 0);
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_R, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_R, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_W, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_W, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_D, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_D, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_I, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_I, MFC_KEY_B) );
assertEqualInt (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_KEYA, MFC_KEY_A) );
assertEqualInt (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_KEYA, MFC_KEY_B) );
assertEqualInt (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_KEYA, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_KEYA, MFC_KEY_B) );
assertEqualInt (1, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_ACCESS_BITS, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_ACCESS_BITS, MFC_KEY_B) );
assertEqualInt (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_ACCESS_BITS, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_ACCESS_BITS, MFC_KEY_B) );
assertEqualInt (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_KEYB, MFC_KEY_A) );
assertEqualInt (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_KEYB, MFC_KEY_B) );
assertEqualInt (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_KEYB, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_KEYB, MFC_KEY_B) );
} while (0);
mifare_classic_test_teardown (tag);
}

29
test/test_authenticate.c Normal file
View file

@ -0,0 +1,29 @@
#include "test.h"
#include <err.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <nfc/nfc.h>
#include "mifare_classic.h"
DEFINE_TEST(authenticate)
{
int res;
MifareClassicTag tag;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicKey k = { 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5 };
res = mifare_classic_authenticate (tag, 0x00, k, MFC_KEY_A);
assertEqualInt (res, 0);
} while (0);
mifare_classic_test_teardown (tag);
}

63
test/test_format.c Normal file
View file

@ -0,0 +1,63 @@
#include "test.h"
#include <err.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <nfc/nfc.h>
#include "mifare_classic.h"
DEFINE_TEST(format)
{
int res;
MifareClassicTag tag;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicKey k = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
res = mifare_classic_authenticate (tag, 0x3c, k, MFC_KEY_A);
assertEqualInt (res, 0);
MifareClassicBlock data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
};
MifareClassicBlock empty;
memset (empty, '\x00', sizeof (empty));
res = mifare_classic_write (tag, 0x3c, data);
assertEqualInt (res, 0);
res = mifare_classic_write (tag, 0x3d, data);
assertEqualInt (res, 0);
res = mifare_classic_write (tag, 0x3e, data);
assertEqualInt (res, 0);
res = mifare_classic_format_sector (tag, 0x03c);
assertEqualInt (res, 0);
res = mifare_classic_read (tag, 0x3c, &data);
assertEqualInt (res, 0);
assertEqualMem (data, empty, sizeof (data));
res = mifare_classic_read (tag, 0x3d, &data);
assertEqualInt (res, 0);
assertEqualMem (data, empty, sizeof (data));
res = mifare_classic_read (tag, 0x3e, &data);
assertEqualInt (res, 0);
assertEqualMem (data, empty, sizeof (data));
res = mifare_classic_read (tag, 0x3f, &data);
assertEqualInt (res, 0);
assertEqualMem (data, "\x00\x00\x00\x00\x00\x00\xff\x07\x80\x69\xff\xff\xff\xff\xff\xff", sizeof (data));
} while (0);
mifare_classic_test_teardown (tag);
}

46
test/test_read_sector_0.c Normal file
View file

@ -0,0 +1,46 @@
#include "test.h"
#include <err.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <nfc/nfc.h>
#include "mifare_classic.h"
DEFINE_TEST(read_sector_0)
{
MifareClassicTag tag;
int res ;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicKey k = { 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5 };
res = mifare_classic_authenticate (tag, 0x00, k, MFC_KEY_A);
assertEqualInt (res, 0);
MifareClassicBlock r;
res = mifare_classic_read (tag, 0x00, &r);
assertEqualInt (res, 0);
extract_reference_file ("test_read_sector_0");
FILE *f = fopen("test_read_sector_0", "r");
char buffer[17];
fgets (buffer, 17, f);
assertEqualMem (r, buffer, 16);
fclose (f);
} while (0);
mifare_classic_test_teardown (tag);
}

4
test/test_read_sector_0.uu Normal file
View file

@ -0,0 +1,4 @@
begin 644 test_read_sector_0
0NL=Z_/N(!`!&756601`9"```
`
end

163
test/test_value_block.c Normal file
View file

@ -0,0 +1,163 @@
#include "test.h"
DEFINE_TEST(value_block_increment)
{
int res;
MifareClassicTag tag;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicBlockNumber block = 0x04;
MifareClassicKey k = { 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7 };
res = mifare_classic_authenticate (tag, block, k, MFC_KEY_A);
assertEqualInt (res, 0);
res = mifare_classic_init_value (tag, block, 1000, 0x00);
assertEqualInt (res, 0);
/* Initialize value block */
int32_t value;
MifareClassicBlockNumber adr;
res = mifare_classic_read_value (tag, block, &value, &adr);
assertEqualInt (res, 0);
assertEqualInt (value, 1000);
assertEqualInt (adr, 0x00);
/* Increment by 1 */
res = mifare_classic_increment (tag, block, 1);
assertEqualInt (res, 0);
res = mifare_classic_transfer (tag, block);
assertEqualInt (res, 0);
res = mifare_classic_read_value (tag, block, &value, &adr);
assertEqualInt (res, 0);
assertEqualInt (value, 1001);
assertEqualInt (adr, 0x00);
/* Increment by 10 */
res = mifare_classic_increment (tag, block, 10);
assertEqualInt (res, 0);
res = mifare_classic_transfer (tag, block);
assertEqualInt (res, 0);
res = mifare_classic_read_value (tag, block, &value, &adr);
assertEqualInt (res, 0);
assertEqualInt (value, 1011);
assertEqualInt (adr, 0x00);
} while (0);
mifare_classic_test_teardown (tag);
}
DEFINE_TEST(value_block_decrement)
{
int res;
MifareClassicTag tag;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicBlockNumber block = 0x04;
MifareClassicKey k = { 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7 };
res = mifare_classic_authenticate (tag, block, k, MFC_KEY_A);
assertEqualInt (res, 0);
res = mifare_classic_init_value (tag, block, 1000, 0x00);
assertEqualInt (res, 0);
/* Initialize value block */
int32_t value;
MifareClassicBlockNumber adr;
res = mifare_classic_read_value (tag, block, &value, &adr);
assertEqualInt (res, 0);
assertEqualInt (value, 1000);
assertEqualInt (adr, 0x00);
/* Decrement */
res = mifare_classic_decrement (tag, block, 1);
assertEqualInt (res, 0);
res = mifare_classic_transfer (tag, block);
assertEqualInt (res, 0);
res = mifare_classic_read_value (tag, block, &value, &adr);
assertEqualInt (res, 0);
assertEqualInt (value, 999);
assertEqualInt (adr, 0x00);
res = mifare_classic_decrement (tag, block, 1000);
assertEqualInt (res, 0);
res = mifare_classic_transfer (tag, block);
assertEqualInt (res, 0);
res = mifare_classic_read_value (tag, block, &value, &adr);
assertEqualInt (res, 0);
assertEqualInt (value, -1);
assertEqualInt (adr, 0x00);
} while (0);
mifare_classic_test_teardown (tag);
}
DEFINE_TEST(value_block_restore)
{
int res;
MifareClassicTag tag;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicBlockNumber block = 0x04;
MifareClassicKey k = { 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7 };
res = mifare_classic_authenticate (tag, block, k, MFC_KEY_A);
assertEqualInt (res, 0);
/* Restore */
extract_reference_file ("sample_value_block");
extract_reference_file ("null_value_block");
MifareClassicBlock data, sample, nul;
read_data_block ("sample_value_block", &sample);
read_data_block ("null_value_block", &nul);
res = mifare_classic_write (tag, block, sample);
assertEqualInt (res, 0);
res = mifare_classic_read (tag, block, &data);
assertEqualInt (res, 0);
assertEqualMem (sample, data, sizeof (data));
res = mifare_classic_write (tag, block+1, nul);
assertEqualInt (res, 0);
res = mifare_classic_read (tag, block+1, &data);
assertEqualInt (res, 0);
assertEqualMem (nul, data, sizeof (data));
res = mifare_classic_restore (tag, block);
assertEqualInt (res, 0);
res = mifare_classic_transfer (tag, block+1);
assertEqualInt (res, 0);
res = mifare_classic_read (tag, block+1, &data);
assertEqualInt (res, 0);
assertEqualMem (sample, data, sizeof (data));
} while (0);
mifare_classic_test_teardown (tag);
}