helpertest.cc 6.35 KB
Newer Older
thomas.forbriger's avatar
thomas.forbriger committed
1
2
3
4
5
/*! \file helpertest.cc
 * \brief test helpers like iterator, subarray and slice (implementation)
 * 
 * ----------------------------------------------------------------------------
 * 
6
 * $Id: helpertest.cc,v 1.3 2002-12-29 16:57:28 forbrig Exp $
thomas.forbriger's avatar
thomas.forbriger committed
7
8
9
10
11
12
13
14
15
 * \author Thomas Forbriger
 * \date 23/12/2002
 * 
 * test helpers like iterator, subarray and slice (implementation)
 * 
 * Copyright (c) 2002 by Thomas Forbriger (IMG Frankfurt) 
 * 
 * REVISIONS and CHANGES 
 *  - 23/12/2002   V1.0   Thomas Forbriger
thomas.forbriger's avatar
thomas.forbriger committed
16
17
 *  - 28/12/2002   V1.1   (thof)
 *                        - new term for containers of const elements
18
19
20
21
22
 *  - 29/12/2002   V1.2   (thof)
 *                        - new subarray function
 *                        - test subarray of ConstArray
 *                        - new slice function
 *                        - test slice of ConstArray
thomas.forbriger's avatar
thomas.forbriger committed
23
24
25
26
 * 
 * ============================================================================
 */
#define AFF_HELPERTEST_CC_VERSION \
27
  "AFF_HELPERTEST_CC   V1.2"
thomas.forbriger's avatar
thomas.forbriger committed
28
#define AFF_HELPERTEST_CC_CVSID \
29
  "$Id: helpertest.cc,v 1.3 2002-12-29 16:57:28 forbrig Exp $"
thomas.forbriger's avatar
thomas.forbriger committed
30
31
32
33
34

/*! \example tests/helpertest.cc
 *
 * Test helper classes.
 *
thomas.forbriger's avatar
thomas.forbriger committed
35
36
37
 * This test program gives an example of the usage of the following classes,
 * functions, and preprocessor macros:
 *   - aff::Iterator
38
39
 *   - aff::util::Subarray
 *   - aff::subarray
thomas.forbriger's avatar
thomas.forbriger committed
40
41
42
43
44
45
46
47
48
 *   - aff::Slice
 *   - aff::Array
 *   - aff::ConstArray
 *   - aff::Shaper
 *   - aff::dump
 *   - aff::dump_array
 *   - #DUMP
 *   - #CODE
 *
thomas.forbriger's avatar
thomas.forbriger committed
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 * \sa tests/helpertest.cc
 */

#include <aff/array.h>
#include <aff/dump.h>
#include <aff/shaper.h>
#include <aff/iterator.h>
#include <aff/subarray.h>
#include <aff/slice.h>

using std::cout;
using std::endl;
using namespace aff;

/*----------------------------------------------------------------------*/

//! print headline
void section(const char* s, const char l='-')
{
  cout << endl << s << endl;
  const char* p=s;
  while (*p) { cout << l; ++p; }
  cout << endl;
}

/*----------------------------------------------------------------------*/

//! test for passing subarrays and slices
template<class T>
thomas.forbriger's avatar
thomas.forbriger committed
78
void printarray(const ConstArray<T>& array)
thomas.forbriger's avatar
thomas.forbriger committed
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
{
  cout << endl;
  cout << "Received array in function:" << endl;
  dump_array(array);
}

/*======================================================================*/

//! test helper classes
int main()
{
  cout << AFF_HELPERTEST_CC_VERSION << endl;
  cout << AFF_HELPERTEST_CC_CVSID << endl;

  section("Preparing test array");
  CODE( Array<int> A(Shaper(-2,2)(-3,3)) );
  CODE( dump_array(A) );

  section("Tests for class Iterator", '=');
  {
    CODE(int i=1);
    CODE(for( Iterator<Array<int> > I(A); I.valid(); ++I) 
         { *I=i; i++; });
    CODE( dump_array(A) );
103
104
105
106
    CODE( ConstArray<int> CA(A.copyout()) );
//    CODE( i=1);
//    CODE(for( Iterator<ConstArray<int> > I(CA); I.valid(); ++I) 
//         { cout << i << ", " << *I << endl; i++; });
thomas.forbriger's avatar
thomas.forbriger committed
107
  }
108
109

  CODE( ConstArray<int> OrigA(A.copyout()) );
thomas.forbriger's avatar
thomas.forbriger committed
110
  
111
112
  /*----------------------------------------------------------------------*/

thomas.forbriger's avatar
thomas.forbriger committed
113
114
  section("Tests for class Subarray", '=');
  {
115
116
117
118
119
120
121
122
123
124
125
126
127
128
    section("First mode: Use a Subarray object just for initialization",'.');
    CODE(Array<int> B=aff::util::Subarray<Array<int> >(A)(-1,1)(-2,2));
    CODE( dump_array(B) );
    CODE(B=-5);
    CODE( dump_array(A) );
    // you must explicitely create an array through member function array()
    CODE(printarray(aff::util::Subarray<Array<int> >(A)(-2,0)(-3,0).array()));
  }
  
  section("Tests of subarray function", '-');
  {
    CODE( A.copyin(OrigA) );
    section("First mode: Use a Subarray object just for initialization",'.');
    CODE(Array<int> B=subarray(A)(-1,1)(-2,2));
thomas.forbriger's avatar
thomas.forbriger committed
129
130
131
    CODE( dump_array(B) );
    CODE(B=-5);
    CODE( dump_array(A) );
132
133
134
135
    section("Second mode: Create a Subarray object to which you can assign",
            '.');
    CODE(subarray(A)()(1,2)=100);
    CODE(subarray(A)(1,1)=-200);
thomas.forbriger's avatar
thomas.forbriger committed
136
137
    CODE( dump_array(A) );
    // you must explicitely create an array through member function array()
138
139
140
141
142
143
144
145
146
147
    CODE(printarray(subarray(A)(-2,0)(-3,0).array()));
  }

  section("Test for subarray of ConstArray",'-');
  {
    CODE( dump_array(OrigA) );
    CODE(ConstArray<int> B=subarray(OrigA)(-1,1)(-2,2));
    CODE( dump_array(B) );
    // you must explicitely create an array through member function array()
    CODE(printarray(subarray(OrigA)(-2,0)(-3,0).array()));
thomas.forbriger's avatar
thomas.forbriger committed
148
149
  }
  
150
151
  /*----------------------------------------------------------------------*/

thomas.forbriger's avatar
thomas.forbriger committed
152
153
  section("Tests for class Slice", '=');
  {
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
    CODE( A.copyin(OrigA) );
    section("First mode: Use a Slice object just for initialization",'.');
    CODE(Array<int> B=aff::util::Slice<Array<int> >(A)(1,-1));
    CODE( dump_array(B) );
    CODE(B=555);
    CODE( dump_array(A) );
    // you must explicitely create an array through member function array()
    CODE(printarray(aff::util::Slice<Array<int> >(A)(-2).array()));
  }

  section("Test slice function", '-');
  {
    CODE( A.copyin(OrigA) );
    section("First mode: Use a Slice object just for initialization",'.');
    CODE(Array<int> B=slice(A)(1,-1));
thomas.forbriger's avatar
thomas.forbriger committed
169
170
171
    CODE( dump_array(B) );
    CODE(B=555);
    CODE( dump_array(A) );
172
173
174
175
    section("Second mode: Create a Slice object to which you can assign",
            '.');
    CODE(slice(A)()(1)=666);
    CODE(slice(A)(0)=-777);
thomas.forbriger's avatar
thomas.forbriger committed
176
177
    CODE( dump_array(A) );
    // you must explicitely create an array through member function array()
178
    CODE(printarray(slice(A)(-2).array()));
thomas.forbriger's avatar
thomas.forbriger committed
179
180
  }

181
182
183
184
185
186
187
188
189
190
191
  section("Test slice of ConstArray",'-');
  {
    CODE( dump_array(OrigA) );
    CODE(ConstArray<int> B=slice(OrigA)(1,-1));
    CODE( dump_array(B) );
    // you must explicitely create an array through member function array()
    CODE(printarray(slice(OrigA)(-2).array()));
  }

  /*----------------------------------------------------------------------*/

thomas.forbriger's avatar
thomas.forbriger committed
192
193
194
195
196
  section("Mixed tests", '=');

  section("Iterator on a Subarray");
  {
    CODE(int i=501);
197
    CODE(Array<int> B=subarray(A)(-1,1)(-2,2));
thomas.forbriger's avatar
thomas.forbriger committed
198
199
200
201
202
203
204
205
    CODE(for( Iterator<Array<int> > I(B); I.valid(); ++I) 
         { *I=i; i++; });
    CODE( dump_array(A) );
  }

  section("Iterator on a Slice");
  {
    CODE(int i=-801);
206
    CODE(Array<int> B=slice(A)(1));
thomas.forbriger's avatar
thomas.forbriger committed
207
208
209
210
211
212
213
    CODE(for( Iterator<Array<int> > I(B); I.valid(); ++I) 
         { *I=i; i++; });
    CODE( dump_array(A) );
  }

  section("Extract copy of subarray");
  {
214
    CODE(Array<int> B=subarray(A)(-1,1)(-1,1));
thomas.forbriger's avatar
thomas.forbriger committed
215
216
217
218
219
220
221
    CODE(dump_array(B));
    CODE(Array<int> C=B.copyout());
    CODE(dump_array(C));
  }
}

/* ----- END OF helpertest.cc ----- */