← Back to branch summary

~ubuntu-branches/ubuntu/vivid/gimp/vivid

« back to all changes in this revision

Viewing changes to plug-ins/metadata/testbase64.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach
  • Date: 2012-05-08 18:50:03 UTC
  • mto: (1.1.26) (0.5.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 71.
  • Revision ID: package-import@ubuntu.com-20120508185003-tltkvbaysf8d2426
Import upstream version 2.8.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/metadata/testbase64.c
1
 
/* Small test program to test the base64 encoding and decoding */
2
 
 
3
 
#include "config.h"
4
 
 
5
 
#include <stdlib.h>
6
 
#include <string.h>
7
 
 
8
 
#include <glib.h>
9
 
 
10
 
#include "base64.h"
11
 
 
12
 
static int
13
 
string_encode_decode (char *s)
14
 
{
15
 
  int  n;
16
 
  char encoded[300];
17
 
  char decoded[400];
18
 
 
19
 
  n = base64_encode (s, strlen (s), encoded, sizeof (encoded) - 1, 0);
20
 
  if (n < 0)
21
 
    {
22
 
      g_print ("base64 encoding failed for '%s'", s);
23
 
      return 1;
24
 
    }
25
 
  g_print ("'%s' -> '%s' (%d) ", s, encoded, n);
26
 
  n = base64_decode (encoded, strlen (encoded), decoded, sizeof (decoded) - 1,
27
 
                     FALSE);
28
 
  if (n < 0)
29
 
    {
30
 
      g_print ("\nbase64 decoding failed for '%s'", s);
31
 
      return 1;
32
 
    }
33
 
  if (! strcmp (s, decoded))
34
 
    g_print ("-> '%s' (%d)\n", decoded, n);
35
 
  else
36
 
    {
37
 
      g_print ("-> '%s' (%d) MISMATCH!\n", decoded, n);
38
 
      g_print ("decoded buffer does not match original!\n");
39
 
      return 1;
40
 
    }
41
 
  return 0;
42
 
}
43
 
 
44
 
static int
45
 
buffer_encode_decode (char *buf,
46
 
                      gint  buf_len,
47
 
                      gint  columns)
48
 
{
49
 
  int  n;
50
 
  char encoded[3000];
51
 
  char decoded[4000];
52
 
 
53
 
  n = base64_encode (buf, buf_len, encoded, sizeof (encoded) - 1, columns);
54
 
  if (n < 0)
55
 
    {
56
 
      g_print ("base64 encoding failed");
57
 
      return 1;
58
 
    }
59
 
  g_print ("buffer length %d -> encoded %d (columns: %d) ", buf_len, n,
60
 
           columns);
61
 
  n = base64_decode (encoded, strlen (encoded), decoded, sizeof (decoded) - 1,
62
 
                     FALSE);
63
 
  if (n < 0)
64
 
    {
65
 
      g_print ("\nbase64 decoding failed");
66
 
      return 1;
67
 
    }
68
 
  if ((n == buf_len) && ! memcmp (buf, decoded, n))
69
 
    g_print ("-> decoded %d match OK\n", n);
70
 
  else
71
 
    {
72
 
      g_print ("-> decoded %d MISMATCH!\n", n);
73
 
      g_print ("decoded buffer does not match original!\n");
74
 
      return 1;
75
 
    }
76
 
  return 0;
77
 
}
78
 
 
79
 
static int
80
 
test_decode (char     *encoded,
81
 
             char     *expected,
82
 
             gint      expected_len,
83
 
             gboolean  ignore_errors)
84
 
{
85
 
  int  n;
86
 
  char decoded[4000];
87
 
 
88
 
  n = base64_decode (encoded, strlen (encoded), decoded, sizeof (decoded) - 1,
89
 
                     ignore_errors);
90
 
  if (n < 0)
91
 
    {
92
 
      if (expected_len < 0)
93
 
        g_print ("'%s' failed as expected\n", encoded);
94
 
      else
95
 
        {
96
 
          g_print ("'%s' could not be decoded (length: %d, expected %d)\n",
97
 
                   encoded, n, expected_len);
98
 
          return 1;
99
 
        }
100
 
    }
101
 
  else if ((n == expected_len) && ! memcmp (expected, decoded, n))
102
 
    {
103
 
      if (ignore_errors)
104
 
        g_print ("'%s' decoded OK (%d) - invalid chars ignored\n", encoded, n);
105
 
      else
106
 
        g_print ("'%s' decoded OK (%d)\n", encoded, n);
107
 
    }
108
 
  else
109
 
    {
110
 
      g_print ("'%s' not decoded as expected (length: %d, expected %d)\n",
111
 
               encoded, n, expected_len);
112
 
      return 1;
113
 
    }
114
 
  return 0;
115
 
}
116
 
 
117
 
int
118
 
main (int   argc,
119
 
      char *argv[])
120
 
{
121
 
  int  failed = 0;
122
 
  int  i;
123
 
  char buf[1000];
124
 
 
125
 
  g_print ("Testing base64 encoding ...\n");
126
 
  failed += string_encode_decode ("");
127
 
  failed += string_encode_decode ("A");
128
 
  failed += string_encode_decode ("AB");
129
 
  failed += string_encode_decode ("ABC");
130
 
  failed += string_encode_decode ("ABCD");
131
 
  failed += string_encode_decode ("ABCDE");
132
 
  failed += string_encode_decode ("ABCDEF");
133
 
  failed += string_encode_decode ("ABCDEFG");
134
 
  failed += string_encode_decode ("ABCDEFGH");
135
 
  failed += string_encode_decode ("ABCDEFGHI");
136
 
  failed += string_encode_decode ("abcdefghik");
137
 
  failed += string_encode_decode ("1234567890abcdefghijklmnopqrstuvwxyz");
138
 
  failed += string_encode_decode ("«© Raphaël»");
139
 
  for (i = 0; i < sizeof (buf); i++)
140
 
    buf[i] = (char) (i % 0xff);
141
 
  failed += buffer_encode_decode (buf, sizeof (buf), 0);
142
 
  failed += buffer_encode_decode (buf, sizeof (buf), 76);
143
 
  failed += buffer_encode_decode (buf, sizeof (buf), 4);
144
 
  failed += buffer_encode_decode (buf, sizeof (buf), 1);
145
 
  for (i = 0; i < sizeof (buf); i++)
146
 
    buf[i] = (char) (0xff - (i % 0xff));
147
 
  failed += buffer_encode_decode (buf, 600, 0);
148
 
  failed += buffer_encode_decode (buf, 500, 0);
149
 
  failed += buffer_encode_decode (buf, 400, 0);
150
 
  failed += test_decode ("QUJD", "ABC", 3, FALSE);
151
 
  failed += test_decode (" Q\tU  J\nDR\rA==", "ABCD", 4, FALSE);
152
 
  failed += test_decode ("?", "", -1, FALSE);
153
 
  failed += test_decode ("?", "", 0, TRUE);
154
 
  failed += test_decode ("////", "\377\377\377", 3, FALSE);
155
 
  failed += test_decode ("---/./(/)/*", "", -1, FALSE);
156
 
  failed += test_decode ("---/./(/)/*", "\377\377\377", 3, TRUE);
157
 
  failed += test_decode ("AA==", "\0", 1, FALSE);
158
 
  failed += test_decode ("AAA=", "\0\0", 2, FALSE);
159
 
  if (failed > 0)
160
 
    {
161
 
      g_print ("%d test(s) failed!\n", failed);
162
 
      return EXIT_FAILURE;
163
 
    }
164
 
  g_print ("No problems detected.\n");
165
 
  return EXIT_SUCCESS;
166
 
}