diff --git a/test/test_decode.c b/test/test_decode.c
--- a/test/test_decode.c
+++ b/test/test_decode.c
@@ -31,6 +31,7 @@
 #include <assert.h>
 
 #include <zbar.h>
+#include "../zbar/decoder/pcard_defs.h"
 
 zbar_decoder_t *decoder;
 
@@ -65,6 +66,11 @@
         zbar_decoder_get_data_length(decoder) == strlen(data);
     pass *= 3;
 
+    // pcard happens to be contained in random junk or in foreign symbols
+    // so it must be ignored
+    if(sym==ZBAR_PCARD && !pass)
+        return;
+
     zprintf(pass, "decode %s:%s\n", zbar_get_symbol_name(sym), data);
 
     if(!expect_sym)
@@ -937,6 +943,122 @@
     encode_addon(data, par, 2);
 }
 
+/*------------------------------------------------------------*/
+/* PCARD encoding */
+
+int pcard_test_initiated = 0;
+int pcard_symbol_count; ///< number of possible symbols
+int *pcard_symbol_codes;       ///< size = pcard_symbol_count - binary codes
+int pcard_bitcount;
+char **pcard_symbol_strings;   ///< size = pcard_symbol_count - strings
+pcard_codes_array_t pcard_codes;      ///< array char*[] taken from pcard_defs.h: codes
+
+void pcard_test_init()
+{
+    int pcard_codes_count;   ///< size of pcard_codes
+    int i, ind;
+    
+    if(pcard_test_initiated) { return; }
+    pcard_test_initiated = 1;
+    macro_fill_array_codes(pcard_codes);
+    pcard_codes_count = sizeof(pcard_codes) / sizeof(pcard_codes[0]);
+    
+    // count all possible symbols
+    pcard_symbol_count = 0;
+    for(i=0; i<pcard_codes_count; i++) {
+        if(pcard_codes[i])
+            pcard_symbol_count++;
+    }
+    if(!pcard_symbol_count) {
+        zprintf(0, "no pcard symbols found\n");
+        return;
+    }
+    
+    // allocate symbol arrays and fill them
+    pcard_symbol_codes = malloc(pcard_symbol_count * sizeof(int));
+    pcard_symbol_strings = malloc(pcard_symbol_count * sizeof(char *));
+    ind = 0;
+    for(i=0; i<pcard_codes_count; i++) {
+        if(pcard_codes[i]) {
+            pcard_symbol_codes[ind] = i;
+            pcard_symbol_strings[ind] = pcard_codes[i];
+            ind++;
+        }
+    }
+
+    pcard_bitcount = -1;
+    while (pcard_codes_count) {
+        pcard_bitcount++;
+        pcard_codes_count >>= 1;
+    }
+    
+    zprintf(2, "pcard init: codes_size:%d symbol_count:%d bits:%d\n",
+               pcard_codes_count, pcard_symbol_count, pcard_bitcount);
+}
+
+int pcard_get_index(char *data)
+{
+    int len, code_index, code;
+    char *symbol_string;
+    pcard_test_init();
+    if(!pcard_symbol_count) return -1;
+
+    len = strlen(data);
+    if(len<4)
+        code_index = atoi(data);
+    else
+        code_index = atoi(data + len - 4);
+    code_index %= pcard_symbol_count;
+    code = pcard_symbol_codes[code_index];
+    symbol_string = pcard_symbol_strings[code_index];
+    zprintf(2, "PCARD: data:%s (symbol index:%d code:%d)\n", symbol_string, code_index, code);
+    return code_index;
+}
+
+void encode_pcard(int code_index)
+{
+    int i, color, w, new_color, code, mask, bitcount;
+    const int unit = 3;
+    
+    assert(zbar_decoder_get_color(decoder) == ZBAR_SPACE);
+    zbar_decode_width(decoder, 5*unit);
+    zbar_decode_width(decoder, 4*unit/5);
+    color = 0;
+    w = 0;
+    code = pcard_symbol_codes[code_index];
+
+    // simulate two 0 bits at both ends
+    code <<= 1;  
+    bitcount = pcard_bitcount + 2;
+    
+    mask = 1 << (bitcount-1);
+    for(i=0; i<bitcount+1; i++) {
+        if(i<bitcount) {
+            new_color = ((code & mask)!=0);
+        }
+        else {
+            // simulate color change at the end of data
+            new_color = !color;
+        }
+        if (color == new_color) {
+            w++;
+        }
+        else {
+            zbar_decode_width(decoder, w*unit);
+            zprintf(3, "    color:%d width:%d\n", color, w);
+            color = new_color;
+            w = 1;
+        }
+        zprintf(4, "    bit%d: %d\n", i, new_color);
+        mask >>= 1;
+    }
+    if(color!=1)
+        zprintf(3, "not good - we should finish with black color\n");
+
+    zbar_decode_width(decoder, 4*unit/5);
+    zbar_decode_width(decoder, 5*unit);
+}
+
 
 /*------------------------------------------------------------*/
 /* main test flow */
@@ -997,6 +1119,7 @@
 
 int test_numeric (char *data)
 {
+    int pcard_index;
     char tmp[32] = "01";
     strncpy(tmp + 2, data + 1, 13);
     calc_ean_parity(tmp + 2, 13);
@@ -1046,6 +1169,13 @@
     encode_ean2(data);
     encode_junk(rnd_size);
 
+    pcard_index = pcard_get_index(data);
+    if(pcard_index >= 0) {
+        expect(ZBAR_PCARD, pcard_symbol_strings[pcard_index]);
+        encode_pcard(pcard_index);
+        encode_junk(rnd_size);    
+    }
+
     expect(ZBAR_NONE, NULL);
     return(0);
 }
@@ -1120,6 +1250,7 @@
     char *end;
 
     decoder = zbar_decoder_create();
+    zbar_decoder_set_config(decoder, ZBAR_PCARD, ZBAR_CFG_ENABLE, 1);
     /* allow empty CODE39 symbologies */
     zbar_decoder_set_config(decoder, ZBAR_CODE39, ZBAR_CFG_MIN_LEN, 0);
     /* enable addons */
